C#

//Create sample data in the same method as OP
IList  datalist = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(typeof(Data)));

datalist.Add(new Data {Name = "SIMON", value = 1});
datalist.Add(new Data {Name = "SIMON", value = 2});
datalist.Add(new Data {Name = "SIMON", value = 3});

//Create the destination object that is declared using
//the dynamic keyword
Type t = typeof(Parent<>);
Type type = typeof(Data);

dynamic response = Activator.CreateInstance(t.MakeGenericType(type));

//************ possible work around not sure if it would be a correct way
//************ but it works.

Type SingleRecordType = datalist[0].GetType();
dynamic Destination = Activator.CreateInstance(SingleRecordType);
Desintation = datalist[0];

//Add the record to the response object
response.value = Desintation;

public sealed class SceneManager
{
  private List<SceneItem> children = new List<SceneItem>();

  public T AddVisual<T>(T visual) where T : SceneItem
  {
    children.Add(visual);
  }
}

public void Draw()
{
  foreach(SceneItem child in children)
  {
    child.Draw();
  }
}

public void Offset(int x, int y)
{
  foreach (SceneItem child in children)
  {
    child.Top += x;
    child.Left += y;
    child.Draw();
  }
}

SerialPort OurChosenSerialPort;

OurChosenSerialPort = new SerialPort(ThePortName, OurChosenSerialPortSpeed,
Parity.None, 0, StopBits.One);

Big Daddy Farang wrote:

I haven't seen the post where Dave and Gerry helped, so maybe you've already done that.

string[] The_List_Of_ComPorts = SerialPort.GetPortNames();

Big Daddy Farang wrote:

From your code snippet it appears that "OurChosenSerialPort" is a varialbe local to the function that opens it. If that's the case, only that function can use it. I would suggest making a member variable so that other functions in that class can use it.

public partial class Form1 : Form
{

public const int OurChosenSerialPortSpeed = 115200;
public const int OurChosenNumberOfDataBits = 8;
public const int SomeIntegerXyzz = 65537;
public string ThePortName;
public SerialPort The_Port_We_Are_Using;

 SerialPort OurChosenSerialPort = new                                  
                                  SerialPort(                          
                                             ThePortName,              
                                             OurChosenSerialPortSpeed, 
                                             Parity.None,              
                                             OurChosenNumberOfDataBits,
                                             StopBits.One              
                                             )                         
                                             ;                         
             
 OurChosenSerialPort.Open
 The_Port_We_Are_Using = OurChosenSerialPort;
();                                           

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.IO.Ports;

namespace YourNameHere
{
   class Device
   {
      private SerialPort Port;
      private const int BufferSize = 256;
      private char[] ReadBuffer;
      private string LastResponse;

      
      public Device(string CommPort)
      {
         if (CommPort.IndexOf("COM", StringComparison.CurrentCultureIgnoreCase) < 0)
         {
            throw new ArgumentException("Argument must be of the form \"COMn\"", "CommPort");
         }
         // the SerialPort constructor may also throw an exception
         Port = new SerialPort(CommPort, 9600, Parity.None, 8, StopBits.One);

         Port.RtsEnable = true;
         Port.DtrEnable = true;
         Port.ReadTimeout = 500;
         Port.WriteTimeout = 500;
         Port.Open();
         Port.DiscardInBuffer();

         ReadBuffer = new char[BufferSize];
      }

      
      // might be handy for debug
      public string GetLastResponse()
      {
         return LastResponse;
      }

      public bool Connect()
      {
         Send("");
         LastResponse = Receive();
         if (LastResponse == "!>")
         {
            return true;
         }
         else
         {
            return false;
         }
      }

      
      public bool SetLoad(int Load)
      {
         string digits;
         if (Load < 10 || Load > 5200)
         {
            throw new ArgumentOutOfRangeException("Load", "Must be between 10 and 5200");
         }

         digits = ResistanceTable(Load);
         Send("L" + digits);
         LastResponse = Receive();
         if (LastResponse == "!>")
         {
            return true;
         }
         else
         {
            return false;
         }
      }

      
      public bool StartMeasuring()
      {
         Send("S");
         LastResponse = Receive();
         if (LastResponse == "!>")
         {
            return true;
         }
         else
         {
            return false;
         }
      }

      public bool StopMeasuring()
      {
         Send("E");
         LastResponse = Receive();
         if (LastResponse == "!>")
         {
            return true;
         }
         else
         {
            return false;
         }
      }
      

      public void Send(string Command)
      {
         if (Port.IsOpen)
         {
            char[] buffer = Command.ToCharArray();
            Port.Write(buffer, 0, buffer.Length);
            Port.Write(new char[] { (char)0x0D }, 0, 1);
         }
      }

      public string Receive()
      {
         const int delay = 75;
         int received = 0;
         char ch;
         StringBuilder result = new StringBuilder();

         if (Port.IsOpen)
         {
            System.Threading.Thread.Sleep(delay);
            try
            {
               received = Port.Read(ReadBuffer, 0, BufferSize);
            }
            catch (TimeoutException)
            {
               result.Append("Error.");
            }
            if (received > 0)
            {
               for (int loop = 0; loop < received; loop++)
               {
                  ch = ReadBuffer[loop];
                  if (ch >= ' ' && ch <= '~')
                  {
                     result.Append(ch);
                  }
               }
            }
         }
         else
         {
            result.Append("Not open.");
         }
         return result.ToString();
      }

      public void Close()
      {
         if (Port.IsOpen)
         {
            Port.Close();
         }
      }
      
   }
}

Big Daddy Farang wrote:

class Device
{
private SerialPort Port;
private const int BufferSize = 256;
private char[] ReadBuffer;
private string LastResponse;
 

public Device(string CommPort)

Pete O'Hanlon wrote:

If you mark something as public, you are telling the compiler that this item can be used from outside the class.

Device device = new Device("COM1");
device.Connect();

string connectResponse = device.LastRepsonse;

string connectResponse = device.GetLastResponse();

public string ThePortName = "";

public partial class Form1 : Form
{

    :
    :
    :
    public string ThePortName;
    :

public Form1()
{

David Knechtges wrote:

"...instantiate the object you are using...."

int count;     // delcare count to be of type int
Device device; // declare device to be of type Device
device = = new Device("COM1");  // instantiate; "device" is now an object

David Knechtges wrote:

Oh and one other thing - USB-Serial devices can cause exceptions when pulled out of a computer while the serial port is open. You will need to be aware of that and handle that as well.