C#

Member 10036172 wrote:

Is there any need to use Visual Studio 2012, as there are some features that you won't find in VS 2012.

Blubbo wrote:

Any suggesion?

   int status = tag_device0.Write_Tag(0, writeDat, en_statusDat, pb);
 
   worker.ReportProgress(pb.Value);
 
   if (ReadTag)
   {
       worker.ReportProgress(0);
       byte[] tagData = new byte[1024];
       tag5_device0.Read_Tag(0, 0, tagData .Length, ref tagData , pb);
       worker.ReportProgress(pb.Value);
    }

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

private void InitializeProgressBars()
{
  for (int i = 0; i < DevicePath.Count; i++)
  {
    progressBar[i] = new ProgressBar();
    progressBar[i].Location = new Point(3, 16);
    progressBar[i].Size = new Size(605, 31);
    progressBar[i].Maximum = 100;
  }
 
  gbProgressStatus0.Controls.Add(progressBar[0]);
  gbProgressStatus1.Controls.Add(progressBar[1]);
  gbProgressStatus2.Controls.Add(progressBar[2]);
  gbProgressStatus3.Controls.Add(progressBar[3]);
}
 
private void InitializeBackgroundWorkers()
{
  for (var f = 0; f < DevicePath.Count; f++)
  {
    bw[f] = new BackgroundWorker();
    bw[f].WorkerReportsProgress = true;
    bw[f].WorkerSupportsCancellation = true;
 
    switch (f)
    {
      case 0:
      {
        bw[f].DoWork += new DoWorkEventHandler(BackgroundWorkerFilesDoWork0);
        bw[f].RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerFilesRunWorkerCompleted0);
        break;
      }
      case 1:
      {
        bw[f].DoWork += new DoWorkEventHandler(BackgroundWorkerFilesDoWork1);
        bw[f].RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerFilesRunWorkerCompleted1);
        break;
      }
      case 2:
      {
        bw[f].DoWork += new DoWorkEventHandler(BackgroundWorkerFilesDoWork2);
        bw[f].RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerFilesRunWorkerCompleted2);
        break;
      }
      case 3:
      {
        bw[f].DoWork += new DoWorkEventHandler(BackgroundWorkerFilesDoWork3);
        bw[f].RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerFilesRunWorkerCompleted3);
        break;
      }
    }
    bw[f].ProgressChanged += (sender, e) => { ((ProgressBar)e.Argument).Value = e.ProgressPercentage; };
  }
}
 
private void BackgroundWorkerFilesDoWork0(object sender, DoWorkEventArgs e)
{
  BackgroundWorker worker = sender as BackgroundWorker;
  worker.ReportProgress(0);
  ProgressBar pb = (ProgressBar)e.Argument;

  System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
  sw.Start();
  // counts on pb being updated safely for threading issues.
  int status = tag_device0.Write_Tag(0, writeDat, en_statusDat, pb);
 
  if (ReadTag)
  {
    worker.ReportProgress(0);
    byte[] tagData = new byte[1024];
    tag5_device0.Read_Tag(0, 0, tagData .Length, ref tagData , pb);
  }
 
  sw.Stop();
  string result = string.Format("Status: {0}    Elapsed: {1}", status, sw.Elapsed.ToString());
  e.Result = result;
}

// Then when the BackgroundWorkers are started:
bw[n].RunWorkerAsync(progressBar[n]);

void UpdateProgressBar(ProgressBar pb, int value)
{
   if (pb.InvokeRequired)
   {
      Action<ProgressBar, int> action = new Action<ProgressBar, int>(UpdateProgressBar);
      object[] obj = new object[] { pb, value };
      pb.BeginInvoke(action, obj);
   }
   else
      pb.Value = value;
}

public int tag5_device0.Read_Tag(<parameters>, ProgressBar pb)
{
   //code snippet

   for (int i = 0; i < 44; i++)
   {
      UpdateProgressBar(pb, i);
}

private static Action<ProgressBar, int> UpdateProgressBarAction = UpdateProgressBar;
private static void UpdateProgressBar(ProgressBar pb, int value)
{
  if (pb.InvokeRequired)
  {
    pb.BeginInvoke(UpdateProgressBarAction, pb, value);
  }
  else
    pb.Value = value;
}

private static Action<ProgressBar, int> UpdateProgressBar = (ProgressBar pb, int value) => {
  if (pb.InvokeRequired)
  {
    pb.BeginInvoke(UpdateProgressBar, pb, value);
  }
  else
    pb.Value = value;
};

larsp777 wrote:

Then the book is added to a List-control owned by the customer-object so the customer-object remembers what books the customer has borrowed.

This works fine when the program is running. The problem occurs when I try to save the objects to disc and then retrieve them again when the program starts. I have asked for help and googled it but I can´t make it work.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

List<Bok> BookList = new List<Bok>();
List<Kund> CustomerList = new List<Kund>();
static string dir = @"C:\Bibliotek\";
string path = dir + "Kunder.xml";
string path2 = dir + "Books.xml";
XmlSerializer xs = new XmlSerializer(typeof(List<Kund>));
XmlSerializer xs2 = new XmlSerializer(typeof(List<Bok>));

public void sparaKund() //Save customerlist
       {


           using (Stream s = File.Create(path))
           {
               xs.Serialize(s,CustomerList);
           }

           using (Stream s2 = File.Create(path2))
           {
               xs2.Serialize(s2, BookList);
           }


       }

private void Form1_Load(object sender, EventArgs e) //Load customerlist
       {

           // deserialize to a new list
           if (File.Exists(path))
           {
               using (Stream s = File.OpenRead(path))
               {

                   CustomerList = (List<Kund>)xs.Deserialize(s);
               }
           }

          if (File.Exists(path2))
          {
              using (Stream s2 = File.OpenRead(path2))
              {
                  BookList = (List<Bok>)xs2.Deserialize(s2);
              }
          }

     }

Book:

 [Serializable()]
    public class Bok : ISerializable

  {
        protected int isbn = 0;
        protected string titel = null;
        protected string author;
        protected int price;
        protected String isType = null;
        protected Kund biblioteksKund = null;

        //egenskaper (properties). Används för att förhindra åtkomst till privata variabler.
        public int ISBN
        {
            get
            {
                return isbn;
            }
            set
            {
                isbn = value;
            }
        }

        public string Titel
        {
            get
            {
                return titel;
            }
            set
            {
                titel = value;
            }
        }

        public string Author
        {
            get
            {
                return author;
            }
            set
            {
                author = value;
            }
        }

        public int Price
        {
            get
            {
                return price;
            }
            set
            {
                price = value;
            }
        }

        public String IsType
        {
            get
            {
                return isType;
            }
            set
            {
                isType = value;
            }
        }
        
        public Kund BiblioteksKund
        {
            get
            {
                return biblioteksKund;
            }
            set
            {
                biblioteksKund = value;
            }
        }


        //Konstruktor (constructor) Metod som körs när objektet skapas. Denna körs om det inte finns parametrar.
        public Bok() 
        {
        }

        //Konstruktor med parametrar
        public Bok(int isbn, string titel, string author, int price, SerializationInfo info, StreamingContext ctxt)
        {
            ISBN = isbn;
            Author = author;
            Titel = titel;
            Price = price;
            biblioteksKund = new Kund();
            this.isbn = (int)info.GetValue("ISBN", typeof(int));
            this.author = (string)info.GetValue("Author", typeof(string));
            this.titel = (string)info.GetValue("Titel", typeof(string));
            this.price = (int)info.GetValue("Price", typeof(int));
            this.biblioteksKund = (Kund)info.GetValue("Kund", typeof(Kund));
         }

        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            info.AddValue("ISBN", this.isbn);
            info.AddValue("Author", this.author);
            info.AddValue("Titel", this.titel);
            info.AddValue("Price", this.price);
            info.AddValue("BiblioteksKund", this.biblioteksKund);
        }
 

        //Metod som skriver ut våra variabler.
        public virtual void skrivUt()
        {
            Console.WriteLine("Författare: {0}", Author);
            Console.WriteLine("Titel: {0}", Titel);
            Console.WriteLine("Pris: {0}", Price);
        }

       public virtual String getInfo()
        {
           return null;
        }

        public String getStatus()
        {
            if (BiblioteksKund != null)
                return ("Utlånad till: " + BiblioteksKund.Name);
            else
                return ("Ej utlånad");
        }
    }
}

Customer:

[Serializable()]
    public class Kund : ISerializable

    {
        private int personNr = 0;
        private string name;
        private List<Bok> loan = new List<Bok>(); 
            


        //egenskaper (properties). Används för att förhindra åtkomst till privata variabler.
        public int PersonNr
        {
            get
            {
                return personNr;
            }
            set
            {
                personNr = value;
            }
        }

        public string Name
        {
            get
            {
                return name;
            }
            set
             {
                name = value;
            }
        }

        public List<Bok> Loan
        {
              get
            {
                return loan;
            }

           // set
            //{
             //  loan = value;
            //}
       }

       

        //Konstruktor (constructor) Metod som körs när objektet skapas. Denna körs om det inte finns parametrar.
        public Kund()
        {
        }

        //Konstruktor med parametrar
        public Kund(int personNr, string name)
        {
            PersonNr = personNr;
            Name = name;
           
        }

        public Kund(SerializationInfo info, StreamingContext ctxt)
        {
            this.personNr = (int)info.GetValue("PersonNr", typeof(int));
            this.name = (string)info.GetValue("Name", typeof(string));
        }

        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            info.AddValue("PersonNr", this.personNr);
            info.AddValue("Name", this.name);
        }
 
        //Metod som skriver ut våra variabler.
        public virtual void skrivUt()
        {
            Console.WriteLine("Personnr: {0}", PersonNr);
            Console.WriteLine("Namn: {0}", Name);
        }
    }

larsp777 wrote:

It's not a Commercial application.

larsp777 wrote:

Well, you set the unique number when you register a book (Bok) or a customer (kund).

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]