C#

Pete O'Hanlon wrote:

Each class there is in a separate namespace.

namespace SerialPortPractice_03    // In one file
namespace SerialPortPractice_03    // In the other file

C-P-User-3 wrote:

Am I close ?

Pete O'Hanlon wrote:

No. In the example you listed above, there were three separate namespaces.

using System;

namespace SerialPortPractice_03

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO.Ports;

namespace SerialPortPractice_03

Pete O'Hanlon wrote:

using SerialPortListener.Serial;
namespace SerialPortListener
{
public class MainForm : Form
{
private SerialPortManager portManager = new SerialPortManager();
....
}
}

namespace WeMakeVehiclesForOthers
{
  public class BaseVehicle
  {
    protected void Buy() {}
  }
}

using WeMakeVehiclesForOthers;
namespace Cars
{
  public class Ford : BaseVehicle
  {
    public void BuyCar()
    {
      Buy(); // We are calling Buy in the BaseVehicle class. Because we have inherited from this class
             // we don't have to do anything special here. As it's protected, we can access it here
             // but classes that don't derive from it can't call it directly.
    }
  }
}

using Cars;
namespace Dealers
{
  public class PetesDealers
  {
    private Ford ford = new Ford();
    public void BuyFord()
    {
      ford.BuyCar();
    }
  }
}

C-P-User-3 wrote:

I have seen other apps run 921600 on this very machine right in front of my
eyes.

Type t = typeof(Parent<>);
int y = 1234;
Type type = y.GetType();

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

public class Parent<T>
{
   public string name = string.Empty;
   public T MyValue;
}

Type t = typeof(Parent<>);
Type type = typeof(Data);

dynamic response = Activator.CreateInstance(t.MakeGenericType(type));
Data es = new Data() { Name = "Fred", value = 213 };
response.value = es;

 public class Parent<T>
   {
       public string name = string.Empty;
       public T value;
   }

   public class Data
   {
       public string Name = string.Empty;
       public int value = 0;
   }

Type genericSyncObj = typeof(SyncObject<>);
						Type syncObj = genericSyncObj.MakeGenericType(type);
IList customObjectList = (IList)Activator.CreateInstance((typeof(List<>).MakeGenericType(type)));

foreach (string value in pullRequest.Knowledge)
{
dynamic syncObject = JasonSerializer.Deserialize(value, syncObj, null);
customObjectList.Add(syncObject.Object);
}

dynamic responseSync = Activator.CreateInstance(typeof(SyncObject<>).MakeGenericType(type));
responseSync.Object =  customObjectList[y] ;

//assume SomeTestClass is the type of class that you are using
//Type type = typeof(SomeTestClass);
responseSync.Object = (SomeTestClass)customObject[y];

//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;