Bonjour,

Comme expliqué dans le titre, j'ai un problème car la Form2() ne ce connecte. Je pense que les variable de la Form1() ne sont pas partagé dans la Form2().

Quand j'utilise la methode Form1.mavariable dans la Form2(), une erreur me dit : 'Form1.mavariable est inaccessible en raison de son niveau de protection'.

Projet :

Pour vous détailler rapidement mon projet, c'est un projet d'application pour allumer les lampe "dali" d'une salle de classe en TPC.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Threading;

namespace Application_DALI
{
    public partial class Form1 : Form
    {
        Form2 form2;
        // Déclaration variables 

        public TcpClient SockClient; // l'objet contenant l'adresse IP + le port (502)
        short val = 0x0000;                                 // % d'éclairement d'une lampe (64=100% || 0 = 0%)
        int pause = 10;                                     // Pour ne pas surcharger le réseau (pour pas envoyer trop de trame d'un coup)
        static byte[] EtatLampes = new byte[16];            // Repertoir d'état des lampes (chaque lampe à un état entre 0 et 100 on les range dans un tableau)
        static string[] AdresseIP = new string[2];          // Tiroir pour les @IP (on peut mettre 2 adresses IP) ???????????
        static string[] AdressePort = new string[2];        // Tiroir pour les numeros de ports (le Port = 502) ??????????????????????? directement dans le main vu qu'lon la change pas
        static short[] AdressesLum = new short[16];         // Repertoir pour les @ des lampes (on envoie les trame aux adresses des esclaves
        public NetworkStream stream; // Créer un stream qui de permet d'envoyer et de recevoir des trames sur l'@ IP spécifié


        // l'API possède une adresse esclave pour communiquer avec les lampes, et a des sorties pour les lampes
        // Chaque sortie = un mot, et un mot = 2 octets, un mot = communication entre 2 lampes
        // j'écris sur un mot les valeurs de lampes que je communique à l'automate
        // Sur la trame que j'envoie je spécifie l'@ du mot sur laquellle je vais écrire et je l'envoie sur l'adresse l'automate.

        bool SIDA;                                          // Etat du damier (inverse ou non)
        bool SIDE;                                          // Sens du degradé
        bool alerte;                                        // Alarme "non connecté" (alarme = Etat déconnecté de l'application)

        //##############################
        //# Gestion des lampes 1 par 1 #
        //##############################
        bool Lampe0, Lampe1, Lampe2, Lampe3, Lampe4, Lampe5, Lampe6, Lampe7, Lampe8, Lampe9, Lampe10, Lampe11, Lampe12, Lampe13, Lampe14;

        ////////////////////////////////////////////////////////////////////////////////////////////
        ///                                     Fonctions                                        ///
        public void WriteTcpWordRequest(TcpClient Sockcli, short AddMot, short valeur)
        {
            try
            {
                byte[] APDU = new byte[15]; // Tableau contenant les élements de la trame ModBus + l'entete modbus
                stream = SockClient.GetStream(); // Créer mon stream correspondant à l'objet, on envoie une trame APDU au Sockclient
                



                //entete ModBus (elle ne change jamais) entete avant l'adresse modbus
                APDU[0] = 0;    //numero requete
                APDU[1] = 0;    //numero requete
                APDU[2] = 0;
                APDU[3] = 0;
                APDU[4] = 0;

                APDU[5] = 9;    //Taille Data ModBus
                APDU[6] = 00;    //Adresse esclave (on s'en fou puisque on a spécifié l'adresse IP de l'esclave)
                APDU[7] = 0x10;    //Code fonction d'écriture d'un mot
                APDU[8] = Convert.ToByte(AddMot / 256);    //Adresse mot à lire Poids Fort
                APDU[9] = Convert.ToByte(AddMot % 256);    //Adresse mot à lire Poids Faible
                APDU[10] = 00;  //Nombre de mot à écrire
                APDU[11] = 01;  //Nombre de mot à écrire
                APDU[12] = 02;  //Nombre octet à écrire
                APDU[13] = Convert.ToByte(valeur / 256);   //Valeur mot Poids Fort
                APDU[14] = Convert.ToByte(valeur % 256);    //Valeur mot Poids Faible


                // Emission avec TimeOut de 100ms
                Sockcli.SendTimeout = 100; // Socklient = objet qui contient l'adresse et le port
                Sockcli.Client.Send(APDU);

                stream.Write(APDU, 0, APDU.Length); // ça sert à écrire la trame
                Thread.Sleep(100); // délai d'envoi entre chaque trame


            }
            catch
            {
                MessageBox.Show("Non connecté");
            }
        }

        private void BTdeconnexion_Click_1(object sender, EventArgs e)
        {
            EteindreTout(SockClient);

            BTconnection.Enabled = true; // on rend le bouton connexion accessible
            BTdeconnexion.Enabled = false; // on rend le bouton deconnexion accessible
            label_connexion.ImageIndex = 0;
            textBoxIP.Text = "";
            textBoxPort.Text = "";
            timer1.Enabled = true;
            SockClient.Close();
        }

        private void label_connexion_Click(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            
            //form2.Show();
        }
        private void hScrollBar_Scroll_pair(int nom)
        {
            EtatLampes[nom] = Convert.ToByte(50);
            Thread.Sleep(pause);
            val = Convert.ToInt16((EtatLampes[nom] * 256) + EtatLampes[nom+1]);
            WriteTcpWordRequest(SockClient, 0x3000, val);
        }

        //Mode lecture - 1/2 allumé & 1/2 à 50%
        private void button4_Click(object sender, EventArgs e)
        {
            label2.Text = "Mode Lecture";
            EtatLampes[1] = Convert.ToByte(50);
            EtatLampes[6] = Convert.ToByte(50);
            EtatLampes[11] = Convert.ToByte(50);
            EtatLampes[3] = Convert.ToByte(50);
            EtatLampes[8] = Convert.ToByte(50);
            EtatLampes[13] = Convert.ToByte(50);
            Thread.Sleep(pause);
            AllumerLampe(SockClient, 0);
            AllumerLampe(SockClient, 5);
            AllumerLampe(SockClient, 10);
            AllumerLampe(SockClient, 12);
            AllumerLampe(SockClient, 7);
            AllumerLampe(SockClient, 2);
            AllumerLampe(SockClient, 14);
            AllumerLampe(SockClient, 9);
            AllumerLampe(SockClient, 4);
            val = Convert.ToInt16((EtatLampes[0] * 256) + EtatLampes[1]);
            WriteTcpWordRequest(SockClient, 0x3000, val);
            val = Convert.ToInt16((EtatLampes[6] * 256) + EtatLampes[7]);
            WriteTcpWordRequest(SockClient, 0x3003, val);
            val = Convert.ToInt16((EtatLampes[10] * 256) + EtatLampes[11]);
            WriteTcpWordRequest(SockClient, 0x3005, val);
            val = Convert.ToInt16((EtatLampes[2] * 256) + EtatLampes[3]);
            WriteTcpWordRequest(SockClient, 0x3001, val);
            val = Convert.ToInt16((EtatLampes[8] * 256) + EtatLampes[9]);
            WriteTcpWordRequest(SockClient, 0x3004, val);
            val = Convert.ToInt16((EtatLampes[12] * 256) + EtatLampes[13]);
            WriteTcpWordRequest(SockClient, 0x3006, val);
        }
        //Fin Mode Lecture

        public void textBoxIP_TextChanged(object sender, EventArgs e)
        {

        }


        // Trame d'écriture
        public void AllumerUneLampe(TcpClient SockCli, int NumLampePoidsFort, int NumLampePoidsFaible, int NumLampeConcern)
        {
            short value;
            EtatLampes[NumLampeConcern] = 0x64; // tableau ou tu va ranger la valeur que tu va attribuer à chaque lampe
            value = Convert.ToInt16((EtatLampes[NumLampePoidsFort] * 256) + EtatLampes[NumLampePoidsFaible]);
            WriteTcpWordRequest(SockCli, AdressesLum[NumLampeConcern], value);
            Thread.Sleep(10);
        }

        // Pour allumer une lampe
        public void AllumerLampe(TcpClient SockCli, int x)
        {
            if (x == 0) AllumerUneLampe(SockCli, 0, 1, 0); // x = numéro de la lampe de laquelle tu va allumer
            if (x == 1) AllumerUneLampe(SockCli, 0, 1, 1);
            if (x == 2) AllumerUneLampe(SockCli, 2, 3, 2);
            if (x == 3) AllumerUneLampe(SockCli, 2, 3, 3);
            if (x == 4) AllumerUneLampe(SockCli, 4, 5, 4);
            if (x == 5) AllumerUneLampe(SockCli, 4, 5, 5);
            if (x == 6) AllumerUneLampe(SockCli, 6, 7, 6);
            if (x == 7) AllumerUneLampe(SockCli, 6, 7, 7);
            if (x == 8) AllumerUneLampe(SockCli, 8, 9, 8);
            if (x == 9) AllumerUneLampe(SockCli, 8, 9, 9);
            if (x == 10) AllumerUneLampe(SockCli, 10, 11, 10);
            if (x == 11) AllumerUneLampe(SockCli, 10, 11, 11);
            if (x == 12) AllumerUneLampe(SockCli, 12, 13, 12);
            if (x == 13) AllumerUneLampe(SockCli, 12, 13, 13);
            if (x == 14) AllumerUneLampe(SockCli, 14, 15, 14);
        }
        // Pour allumer une lampe (version plus pratique)
        public void AllumerTout(TcpClient SockCli)
        {
            int i = 0;
            bool toto = true;

            for (int k = 0; k < 30; k++)
            {
                if (toto)
                {
                    AllumerUneLampe(SockCli, i, i + 1, i + 1);
                    toto = !toto;
                }
                else
                {
                    AllumerUneLampe(SockCli, i, i + 1, i);
                    i = i + 1;
                    toto = !toto;
                }
            }
        }

        // Allumer toutes les lampes
        public void EteindreUneLampe(TcpClient SockCli, int NumLampePoidsFort, int NumLampePoidsFaible, int NumLampeConcern)
        {
            short value2;
            EtatLampes[NumLampeConcern] = 0x00;
            value2 = Convert.ToInt16((EtatLampes[NumLampePoidsFort] * 256) + EtatLampes[NumLampePoidsFaible]);
            WriteTcpWordRequest(SockCli, AdressesLum[NumLampeConcern], value2);
            Thread.Sleep(10);
        }
        // Eteindre une lampe
        public void EteindreLampe(TcpClient SockCli, int x)
        {
            if (x == 0) EteindreUneLampe(SockCli, 0, 1, 0);
            if (x == 1) EteindreUneLampe(SockCli, 0, 1, 1);
            if (x == 2) EteindreUneLampe(SockCli, 2, 3, 2);
            if (x == 3) EteindreUneLampe(SockCli, 2, 3, 3);
            if (x == 4) EteindreUneLampe(SockCli, 4, 5, 4);
            if (x == 5) EteindreUneLampe(SockCli, 4, 5, 5);
            if (x == 6) EteindreUneLampe(SockCli, 6, 7, 6);
            if (x == 7) EteindreUneLampe(SockCli, 6, 7, 7);
            if (x == 8) EteindreUneLampe(SockCli, 8, 9, 8);
            if (x == 9) EteindreUneLampe(SockCli, 8, 9, 9);
            if (x == 10) EteindreUneLampe(SockCli, 10, 11, 10);
            if (x == 11) EteindreUneLampe(SockCli, 10, 11, 11);
            if (x == 12) EteindreUneLampe(SockCli, 12, 13, 12);
            if (x == 13) EteindreUneLampe(SockCli, 12, 13, 13);
            if (x == 14) EteindreUneLampe(SockCli, 14, 15, 14);
        }

        // Eteindre une lampe plus pratique

        public void EteindreTout(TcpClient SockCli)
        {
            int i = 0;
            bool toto = true;

            for (int k = 0; k < 30; k++)
            {
                if (toto)
                {
                    EteindreUneLampe(SockCli, i, i + 1, i + 1);
                    toto = !toto;
                }
                else
                {
                    EteindreUneLampe(SockCli, i, i + 1, i);
                    i = i + 1;
                    toto = !toto;
                }
            }
        } // Eteindre toutes les lampes

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (alerte)
            {
                label_connexion.BackColor = Color.Red;
                alerte = !alerte;
            }
            else
            {
                label_connexion.BackColor = Color.Gray;
                alerte = !alerte;
            }
        }   // Clignote en rouge si déconnecté; Vert si connecté




        public Form1()
        {
            InitializeComponent();
            AdresseIP[0] = "127.0.0.1";
            AdressePort[0] = "502";

            AdresseIP[1] = "";
            AdresseIP[1] = "";

            AdressesLum[0] = AdressesLum[1] = 0x3000;
            AdressesLum[2] = AdressesLum[3] = 0x3001;
            AdressesLum[4] = AdressesLum[5] = 0x3002;
            AdressesLum[6] = AdressesLum[7] = 0x3003;
            AdressesLum[8] = AdressesLum[9] = 0x3004;
            AdressesLum[10] = AdressesLum[11] = 0x3005;
            AdressesLum[12] = AdressesLum[13] = 0x3006;
            AdressesLum[14] = AdressesLum[15] = 0x3007;
        }

        ///////////////////////////////////////////////////////////////////
        ///     Gestion de la connexion
        public void BTconnection_Click(object sender, EventArgs e)
        {
            SockClient = new TcpClient(AddressFamily.InterNetwork);
            try
            {
                SockClient.Connect(textBoxIP.Text, Convert.ToInt32(textBoxPort.Text));
                if (SockClient.Connected)
                {
                    label_connexion.ImageList = imageList1;
                    label_connexion.ImageIndex = 1;
                }

                //label_connexion.BackColor = Color.Green;
                BTconnection.Enabled = false;
                BTdeconnexion.Enabled = true;
                timer1.Enabled = false;
                EteindreTout(SockClient);
            }
            catch
            {
                MessageBox.Show("Saisie invalide");
            }

        } // Bouton de connexion

        private void panel3_Paint(object sender, PaintEventArgs e)
        {

        }

        private void label1_Click(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)
        {
            label2.Text = "Mode Allumage de la Salle entière";
            AllumerTout(SockClient);

        }

        private void button5_Click(object sender, EventArgs e)
        {
            EteindreTout(SockClient);
            label2.Text = "Mode Eteindre la Salle entière";
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Threading;
namespace Application_DALI
{
    public partial class Form2 : Form
    {
        public TcpClient SockClient;
        Form1 form1;
        public Form2()
        {
            InitializeComponent();
            SockClient = new TcpClient(AddressFamily.InterNetwork);
            SockClient.Connect("127.0.0.1", 502);
        }

        private void label_scroll_ClientSizeChanged(object sender, EventArgs e)
        {
            label_scroll.Text = Convert.ToString(scroll_bar.Value);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form1.textBoxIP
            //AllumerLampe(SockClient, 0);
        }
    }
}

Je t'avoue que j'ai pas la tête de lire tout ton programme j'ai un gros mal de crâne, mais déjà si ça peut t'aider normalement ce type d'erreur c'est relatif à l'accès de la variable public/internal/protected/private 

A vue de nez tu déclares dans form2, une form1 est vice versa. Si tu appelles Form2 depuis Form1, vu que tu as déclaré dans Form1 il ne devrait pas y avoir de problème et tu vas accéder aux variables publiques. Maintenant tu pourras pas accéder à Form2 depuis Form2 même si c'est la classe puisque tu auras créé un objet unique de type form2.

Là faudrait en dire un peu plus, sur ce à quoi tu veux accéder où et quand.


edit: et à moins que j'ai mal vu tu n'initialises pas un objet Form1, tu ne crées pas l'objet si tu veux. Et vu que ça à la variable n'a pas de modificateur d'accès elle est normalement en privé, donc en toute logique c'est normalement form2 qui devrait intialiser l'objet form1 de type Form1. 

Edit2: regarde les conventions de nommage stp. Ca sera plus simple pour toi et pour les autres quand ils te liront

-
Edité par Daerlnaxe 25 mars 2022 à 15:08:03

De quel champ de Form1 "mavariable" il s'agit ? Parce que les champs de Form 1, c'est un vrai foutoir, entre les champs statique, les champs d'instance publics, les champs d'instance interne (parce qu'explicite la visibilité d'un champ c'est pour les mauvais programmeurs ?), sans compter, comme l'indique mon VDD, que les conventions de nommage c'est pour les neuneus ?

Et par quel miracle de la sainte technologie le champ "form1" de la classe Form2 serait "connecté" à l'instance de Form1 créé par la méthode main (entry point) ?

En tout cas, remplacer form1 par Form1, c'est pas une formule magique très efficace.

Reprenez les bases : distinction variable locale/ champ d'instance, champ statique de classe / champ d'instance, classe / instance, ...