C#

DaveyM69 wrote:

I slightly disagree with Leppie on this one.

leppie wrote:

ever so slight

DaveyM69 wrote:

Take the Size struct as an example. It's not immutable, but a struct makes perfect sense and using it within your own struct would be good too.

NodeModuleLevelStruct temp;<br />
temp = theArray[42];<br />
temp.IsActive = true;<br />
theArray[42] = temp;

DaveyM69 wrote:

I can work on the copy, make any changes I like and then just forget the whole thing if I don't want/need to commit them. If it's a class, to have that flexibility you have to implement some sort of cloning method and work on the clone, then you still have to remember to reassign.

Guffa wrote:

a large struct requires a loop to copy the memory area each time.

It's easier to use a struct for cloning instead of implementing proper cloning for a class, but you get worse performance.

reza assar wrote:

dataGridview1.DataSource = dataset1.Tables[0];

public static void DataGridView_Fill(DataGridView dgv, string store_procedure)
{
SqlConnection sql_conn = new SqlConnection(connection_string);
SqlCommand sql_cmd = new SqlCommand();
sql_cmd.Connection = sql_conn;
sql_cmd.CommandText = store_procedure;
sql_cmd.CommandType = CommandType.StoredProcedure;
sql_conn.Open();
SqlDataAdapter sql_da = new SqlDataAdapter();
sql_da.SelectCommand = sql_cmd;
DataTable dt = new DataTable();
sql_da.Fill(dt);
sql_conn.Close();
dgv.DataSource = dt;
}

public interface IMyInterface
{
    void WriteMe();
}
public class A : IMyInterface
{
    public void WriteMe()
    {
        Console.Write("A");
    }
}
public class B : IMyInterface
{
    public void WriteMe()
    {
        Console.Write("B");
    }
}
public class C : IMyInterface
{
    public void WriteMe()
    {
        Console.Write("C");
    }
}
public class D
{
    public void WriteParameter(IMyInterface test)
    {
        test.WriteMe();
    }
}

D d = new D();
d.WriteParameter(new A());
d.WriteParameter(new B());
// ...

public class A
{
    private List<a> list = new List<a>();
    public List<a> GetAllRecords() { get { return list; } }
}
public class B
{
    private List<b> list = new List<b>();
    public List<b> GetAllRecords() { get { return list; } }
}
public class C
{
    private List<c> list = new List<c>();
    public List<c> GetAllRecords() { get { return list; } }
}

public class D
{
    private A a = new A();
    private B b = new B();
    private C c = new C();

    private List<a> aList;
    private List<b> bList;
    private List<c> cList;

    public D()
    {
    }

    private List<a> GetAllRecords(A a)
    {
        aList = a.GetAllRecords;
    }

    private List<b> GetAllRecords(B b)
    {
        bList = b.GetAllRecords;
    }

    private List<c> GetAllRecords(C c)
    {
        cList = c.GetAllRecords;
    }
}