Opa! olha eu ai novamente =D, tentando passar algo de (INUTIL) UTIL pra vocês.

Hoje vou mostrar como converter uma List para DataSet, é Super Simples, vamos lá:

public static class ListConvertor
 {
 public static DataSet ConvertToDataSet<T>(IList list)
 {
 DataSet dataSet = new DataSet();

 CreateDataSet(dataSet, typeof(T), false);
 FillDataSet(typeof(T), list, dataSet, -1);
 CreateRelations(dataSet, typeof(T), null);

 return dataSet;
 }

 ///
 /// Create the structure for all the tables in the data set
 ///
 /// Data set in which tables will be created
 /// Type of which dataset has to be created
 /// Whether current type is a child table
 private static void CreateDataSet(DataSet dataSet, Type type, bool isChildTable)
 {
 DataTable dataTable = new DataTable(type.Name);

 //Create the ID columns for having relation in the tables
 dataTable.Columns.Add(new DataColumn("ID2", typeof(int)));
 if (isChildTable)
 {
 dataTable.Columns.Add(new DataColumn("ParentID2", typeof(int)));
 }

 // Create the structure for the data tables to be
 // added in the the data set
 foreach (PropertyInfo pInfo in type.GetProperties())
 {
 if (pInfo.PropertyType.IsGenericType &&
 (pInfo.PropertyType.GetGenericTypeDefinition() == typeof(List<>)
 || pInfo.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
 {
 // If associate lists are there make then another table
 CreateDataSet(dataSet,pInfo.PropertyType.GetGenericArguments()[0],true);
 }
 else
 {
 dataTable.Columns.Add(new DataColumn(pInfo.Name, pInfo.PropertyType));
 }
 }

 //Add the table to the dataset
 dataSet.Tables.Add(dataTable);
 }

 ///
 /// Fill all the tables of data set with data in the respective list
 ///
 /// Type of which datatable is to be filled
 /// List of data
 /// Data Set in which data tables will be filled with data
 /// ID of parent record. If -1 one then no parent
 private static void FillDataSet(Type type, IList list, DataSet dataSet, int parentID)
 {
 PropertyInfo[] propertyInfos = type.GetProperties();
 DataTable dataTable = dataSet.Tables[type.Name];
 int id = dataTable.Rows.Count + 1;

 foreach (object item in list)
 {
 DataRow row = dataTable.NewRow();

 // Set new id and related parent id
 row["ID"] = id;
 if (parentID != -1)
 row["ParentID"] = parentID;

 // Load all the data from the properties of the type
 // and save them into the datatable
 foreach (PropertyInfo info in propertyInfos)
 {
 if (info.PropertyType.IsGenericType &&
 (info.PropertyType.GetGenericTypeDefinition() == typeof(List<>)
 || info.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
 {
 IList subList = (IList)info.GetValue(item, null);
 if (subList != null && subList.Count > 0)
 {
 FillDataSet(subList[0].GetType(),
 subList,
 dataSet, id);
 }
 }
 else
 {
 row[info.Name] = info.GetValue(item, null);
 }
 }

 dataTable.Rows.Add(row);
 id++;
 }
 }

 ///
 /// Creates the relation between the tables according to the
 /// type and parent table on field ID and ParentID
 ///
 /// Data set containing parent and child table
 /// Type of the list
 /// Parent table to which relations has to be done
 private static void CreateRelations(DataSet dataSet, Type type, DataTable parentTable)
 {
 DataTable dataTable = dataSet.Tables[type.Name];

 // If parent table exsits then create relation
 // with child table on field Parent ID
 if (parentTable != null)
 {
 dataSet.Relations.Add(
 new DataRelation(parentTable.TableName + "_ID_"
 + "PARENTID_" + dataTable.TableName,
 parentTable.Columns["ID"],
 dataTable.Columns["ParentID"]));
 }

 // Check for other lists under current object
 // go for another relation if exists
 foreach (PropertyInfo pInfo in type.GetProperties())
 {
 if (pInfo.PropertyType.IsGenericType &&
 (pInfo.PropertyType.GetGenericTypeDefinition() == typeof(List<>)
 || pInfo.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
 {
 // If associate lists are there make then another table
 CreateRelations(dataSet,pInfo.PropertyType.GetGenericArguments()[0],dataTable);
 }
 }
 }
 }

Vamos para as explicações:

ArrayList sequence = new ArrayList();
 IList list = (IList)sequence;
 DataSet ds = ListConvertor.ConvertToDataSet<LancamentosDetalhado>(list);

Como nos queremos passar uma List para DataSet, vamos forçar um ArrayList ser uma lista, já que ele extend de IList, estamos fazendo isso com o cast (IList), logo após aplicamos o metodo STATIC, ListConvertor.ConvertToDataSet<LancamentosDetalhado>(list);,

pois a assinatura do metodo esta como static, logo só pode ser chamado a partir da classe.

Simples assim.

try
            {
            return new SubSonic.Select("nome").From("clientes")
                .WhereExpression("nome").Like("%"+nm+"%")
                .ExecuteAsCollection<ClienteCollection>();
             }catch(SubSonic.SqlQueryException ex)
            {
                throw new SubSonic.SqlQueryException(ex.ToString());
            }finally{
 Connection().Close();
}

1º o try ele vai fazer o que está la dentro
2º se houver algum erro ele captura com o catch
3º independente se houver erro ou não ele executa o que esta no finally

Lógico que podemos colocar algo mais gostoso e complexo ai, mas não é o que estamos tentando abordar neste post… =P

Simples Assim…

Classificação segundo GoF:
Estrutural de Objeto

Propósito:
Usa compartilhamento para dar suporte a grandes quantidades de objetos, de granularidade fina, eficientemente.

Para evitar o overhead associado com o uso de milhares de instâncias, queremos criar um pool de instâncias reutilizávuma nova instância tivesse sido criada para cada uso.

Sabe quando vc tem akele monte de objetos iguais, que vc usa e precisa toda hora instanciar, ou tem um monte de objetos iguais. ex.: um editor de textos. EX.:

com esse padrão vc faz um pool que guarda as instancias e retorna a referencia do mesmo para ser usado, no caso da casa só é preciso de um triangulo um quadrado e um losango… que são reusados…

Facil assim…

o Design Pattern Template Method e Factoy Method são muito uteis pois tiram codigos inuteis da sua classe concreta e centraliza tudo em uma classe abstrata… ou seja seu codigo vai ficar limpo e lindo… OO =D SRP

Pra que serve?

O themplete method como o nome diz é um methodo que vc ia ter q fazer nas sub classes e teria que reescrevelo em todas as subclasses, igual em todas elas, mudando apenas uma regiao… o template method ajuda nesse ponto, pois se vc escrever o methodo na classe abstrata ele vai ser herdado pelas subclasses logo vc vai ter q modificar apenas akele pequeno fragmento de codigo que cada classe faz diferente…

1º Faça o seu templete method…

public Algarism getAlgarism(int code){
  if(code9){
   throw new IllegalArgumentException("Só pode estar entre 0 e 9 tolinho...");
  }else{
   if (this.algarismos[code]!=null){
    return this.algarismos[code];
   }else{
    Algarism alg = this.create(code);

    if (alg == null)
     throw new NullPointerException("Algarismo esta nulo...");

    this.algarismos[code]=alg;
    return this.algarismos[code];
   }
  }
 }

veja q temos uma abstração Algarism que recebe um this.crate(code>); esse vai ser o nosso metodo que muda nas subclasses, logo teremos que crialo como abstrato, para que seja forçada a criação dele nas subclasses...

protected abstract Algarism create(int code);

2º pronto agora vamos nas subclasses e apenas criamos o metodo create... que é o nosso Factoy Method:

protected Algarism create(int code){
  return new SymbolAlgarism(code);
 }

 protected Algarism create(int code){
  return new TextAlgarism(code);
 }

public static Process RunningInstance()
            {
                Process current = Process.GetCurrentProcess();
                Process[] processes = Process.GetProcessesByName (current.ProcessName);

                //Loop through the running processes in with the same name
                foreach (Process process in processes)
                {
                    //Ignore the current process
                    if (process.Id != current.Id)
                    {
                        //Make sure that the process is running from the exe file.
                        if (Assembly.GetExecutingAssembly().Location.Replace("/", "\\") ==
                        current.MainModule.FileName)
                        {
                            //Return the other process instance.
                            return process;
                        }
                    }
                }

            //No other instance was found, return null.
            return null;
            }

  public static void HandleRunningInstance(Process instance)
            {
                //Make sure the window is not minimized or maximized
                ShowWindowAsync (instance.MainWindowHandle , WS_SHOWNORMAL);

                //Set the real intance to foreground window
                SetForegroundWindow (instance.MainWindowHandle);
            }

            [DllImport("User32.dll")]

            private static extern bool ShowWindowAsync(
            IntPtr hWnd, int cmdShow);
            [DllImport("User32.dll")] private static extern bool
            SetForegroundWindow(IntPtr hWnd);
            private const int WS_SHOWNORMAL = 1;

       [STAThread]
        static void Main()
        {

            //Get the running instance.
            Process instance = RunningInstance();

            if (instance == null)
            {
                //There isn't another instance, show our form.
                Application.Run (new frmLogin());
            }
            else
            {
                //There is another instance of this process.
                HandleRunningInstance(instance);
            }

        }

aplique isso a sua aplicação e terá sucesso…