C#

BillWoodruff wrote:

Am I understanding what you are asking here correctly ?

namespace JorgenQuestion
{
  class Program
  {
    static void Main(string[] args)
    {
      Chooser<ClassA> chooser = new Chooser<ClassA>();
      Chooser<ClassB> chooser2 = new Chooser<ClassB>();
    }
  }

  public class ClassA
  {
  }

  public class ClassB
  {
  }

  public class Chooser<T>
  {
  }
}

.class private auto ansi beforefieldinit JorgenQuestion.Program
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor () cil managed
    {
        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: ret
    }

    .method private hidebysig static void Main (
            string[] args
        ) cil managed
    {
        .entrypoint
        .locals init (
            [0] class JorgenQuestion.Chooser`1<class JorgenQuestion.ClassA> chooser,
            [1] class JorgenQuestion.Chooser`1<class JorgenQuestion.ClassB> chooser2
        )

        IL_0000: nop
        IL_0001: newobj instance void class JorgenQuestion.Chooser`1<class JorgenQuestion.ClassA>::.ctor()
        IL_0006: stloc.0
        IL_0007: newobj instance void class JorgenQuestion.Chooser`1<class JorgenQuestion.ClassB>::.ctor()
        IL_000c: stloc.1
        IL_000d: ret
    }
}

Member 10636998 wrote:

I would like to know there is a similiar way to access direct an instance of a GUI or not

/// <summary>
/// Load a sheet from an Excel file
/// </summary>
/// <param name="path">Path to excel file</param>
/// <param name="columns">Comma separated list of columns to load. If not specified, loads all</param>
/// <param name="sheet">Sheet name to load. If not specified, loads "Sheet1$"</param>
/// <param name="verify">If true, checks that the file and sheet exist, and throws exceptions if not. Defaults to true</param>
/// <returns>Table of data retrieved.</returns>
public static System.Data.DataTable LoadExcel(string path, string columns = "*", string sheet = "Sheet1$", bool verify = true)
    {
    if (verify)
        {
        if (!File.Exists(path)) throw new IOException("The input file does not exist: " + path);
        if (!GetExcelSheetNames(path).Contains(sheet)) throw new ArgumentException("The requested sheet does not exist: " + sheet);
        }
    if (string.IsNullOrWhiteSpace(columns)) columns = "*";

    System.Data.DataTable dt = new System.Data.DataTable();
    using (OleDbConnection con = new OleDbConnection(GetExcelConnectionString(path)))
        {
        con.Open();
        string cmdStr = string.Format("SELECT {0} FROM [{1}]", columns, sheet);
        using (OleDbCommand cmd = new OleDbCommand(cmdStr, con))
            {
            using (OleDbDataAdapter da = new OleDbDataAdapter(cmd))
                {
                da.Fill(dt);
                }
            }
        }
    return dt;
    }
/// <summary>
/// Returns a list of all sheet names in an Excel File.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static List<string> GetExcelSheetNames(string path)
    {
    List<string> sheetNames = new List<string>();
    using (OleDbConnection con = new OleDbConnection(GetExcelConnectionString(path)))
        {
        con.Open();
        using (DataTable sheets = con.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null))
            {
            foreach (DataRow sheet in sheets.Rows)
                {
                if (sheet["TABLE_NAME"].ToString().Contains("$"))
                    {
                    // Filtered to just sheets - they all end in '$'
                    sheetNames.Add(sheet["TABLE_NAME"].ToString());
                    }
                }
            }
        }
    return sheetNames;
    }
/// <summary>
/// Returns a connection string for an Excel file
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private static string GetExcelConnectionString(string path)
    {
    return string.Format(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0}; Extended Properties=Excel 12.0", path);
    }

/// <summary>
/// Load data into SQL from a DataTable
/// </summary>
/// <param name="strConnect"></param>
/// <param name="tableName"></param>
/// <param name="table"></param>
public static void LoadSql(string strConnect, string tableName, DataTable table)
    {
    using (SqlConnection con = new SqlConnection(strConnect))
        {
        try
            {
            con.Open();
            using (SqlBulkCopy bulk = new SqlBulkCopy(con))
                {
                bulk.DestinationTableName = tableName;
                bulk.WriteToServer(table);
                }
            }
        finally
            {
            con.Close();
            }
        }
    }

OriginalGriff wrote:

and being able to transfer the data from the one to the other makes life a lot easier