C# Where.Add方法代码示例

        /// <summary>
        /// Pesquisar todos os movimentos utilizando a SearchWindow 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnPesquisarMovimento_Click(object sender, EventArgs e)
        {
            IParentModel tipoMovimento = null;

            // Aqui verifica o tipo de movimento que o usuário quer pesquisar
            if (rbtDAV.Checked)
                tipoMovimento = new DAV();
            else if (rbtDAVOS.Checked)
                tipoMovimento = new Data.Faturamento.Lancamento.Movimento.DAV.OS.DAV();
            else
                tipoMovimento = new PreVenda();

            //Filtro para trazer somente os movimentos que estão com o status: Aberto
            Where where = new Where();
            where.Add("fat_lan.status = @status",
                new Parameter
                {
                    ParameterName = "@status",
                    Value = (int)Enuns.Faturamento.Lancamento.Status.Aberto
                });

            // Fazer a Pesquisa e pegar o GUID movimento selecionado
            SearchWindowResult result = SearchWindow.Show(tipoMovimento, where);

            if (!result.GUID.IsNullOrEmpty())
                CarregarMovimento(result.GUID);
        }

        /// <summary>
        /// Pesquisa os voucher disponíveis
        /// </summary>
        /// <param name="sender">Objeto que disparou o evento</param>
        /// <param name="e">Argumento do evento gerado</param>
        private void btnPesquisar_Click(object sender, EventArgs e)
        {
            Where where = new Where();
            where.Add("fat_lan.status = @status",
                new Parameter
                {
                    ParameterName = "@status",
                    Value = (int)Enuns.Faturamento.Lancamento.Status.Aberto
                });

            IDevolucao devolucao = new Devolucao();

            //Procura somente os vouchers no qual o status está aberto
            SearchWindowResult result = SearchWindow.Show(devolucao, where);

            //Se encontrou carrega os valores do número e valor do voucher
            if (!result.GUID.IsNullOrEmpty())
            {
                devolucao = Data.Abstract.Faturamento.Lancamento.LancamentoBase.Create(result.GUID, false) as IDevolucao;

                txtVoucher.Text = devolucao.EGUID.ToString();
                mnValor.Value = devolucao.ValorTotalLiquido;
                mnValor.Enabled = false;
            }
        }

        protected override void PrepareReader(Command command, Where where)
        {
            base.PrepareReader(command, where);

            //-------------------------------------------------------------------------
            // Filtrar pelo tipo de item especial
            //-------------------------------------------------------------------------
            where.Add("cad_ItemEsp.Tipo", (int)Tipo);
        }

        public override void Validate(bool updating)
        {
            base.Validate(updating);

            #region vars
            Where where = new Where();
            object value = null;
            #endregion

            foreach (IDescontoRegraFiltro filtro in Filtros)
            {
                //-------------------------------------------------------------------------
                // Pesquisar por todos os campos do fitro
                //-------------------------------------------------------------------------
                value = filtro.Cliente.IsNullOrEmpty() ? null : (object)filtro.Cliente.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDCliente = @p1 OR cad_DescontoRegraFiltro.GUIDCliente IS NULL)", value), new Parameter
                {
                    ParameterName = "@p1",
                    Value = value
                });

                value = filtro.CondicaoPagamento.IsNullOrEmpty() ? null : (object)filtro.CondicaoPagamento.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDCondPgto = @p2 OR cad_DescontoRegraFiltro.GUIDCondPgto IS NULL)", value ), new Parameter
                {
                    ParameterName = "@p2",
                    Value = value
                });

                value = filtro.Estado.IsNullOrEmpty() ? null : (object)filtro.Estado.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDEstado = @p3 OR cad_DescontoRegraFiltro.GUIDEstado IS NULL)", value ), new Parameter
                {
                    ParameterName = "@p3",
                    Value = value
                });

                value = filtro.Fabricante.IsNullOrEmpty() ? null : (object)filtro.Fabricante.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDFabricante = @p4 OR cad_DescontoRegraFiltro.GUIDFabricante IS NULL)", value), new Parameter
                {
                    ParameterName = "@p4",
                    Value = value
                });

                value = filtro.GrupoItem.IsNullOrEmpty() ? null : (object)filtro.GrupoItem.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDGrupoItem = @p5 OR cad_DescontoRegraFiltro.GUIDGrupoItem  IS NULL)", value ), new Parameter
                {
                    ParameterName = "@p5",
                    Value = value
                });

                value = filtro.Item.IsNullOrEmpty() ? null : (object)filtro.Item.GUID;
                where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDItem = @p6 OR cad_DescontoRegraFiltro.GUIDItem IS NULL)", value ), new Parameter
                {
                    ParameterName = "@p6",
                    Value = value
                });
                value = filtro.Quantidade;
                where.Add(String.Format("(cad_DescontoRegraFiltro.Quantidade = @p7  OR cad_DescontoRegraFiltro.Quantidade IS NULL)", value ), new Parameter
                {
                    ParameterName = "@p7",
                    Value = value
                });

               value = filtro.Vendedor.IsNullOrEmpty() ? null : (object)filtro.Vendedor.GUID;
               where.Add(String.Format("(cad_DescontoRegraFiltro.GUIDVendedor = @p8 OR cad_DescontoRegraFiltro.GUIDVendedor IS NULL)", value ), new Parameter
               {
                   ParameterName = "@p8",
                   Value = value
               });

                IList<IDescontoRegra> regras = new DescontoRegra().Find<IDescontoRegra>(where);
                //-------------------------------------------------------------------------
                // Localizar a lista de regras
                //-------------------------------------------------------------------------
                if (regras.Count(w => w.GUID != GUID) > 0)
                {
                    throw new Exceptions.Regra.FilterAlreadyExists(Convert.ToString(regras[0].Descricao));
                }
            }
        }

        /// <summary>
        /// Executas as validações impostas pela classe
        /// </summary>
        /// <param name="updating">Determina se é update ou insert</param>
        public override void Validate(bool updating)
        {
            base.Validate(updating);

            Where where = new Where();
            object value = null;

            foreach (IRegraFiltro item in Filtros)
            {
                //Pesquisar todos os filtros da regra de análise de crédito
                value = item.Cliente.IsNullOrEmpty() ? null : (object)item.Cliente.GUID;
                where.Add(string.Format("cad_AnaliseCreditoRegraFiltro.GUIDCliente {0} @p1", value == null ? "is" : "="), new Parameter
                {
                    ParameterName = "@p1",
                    Value = value
                });

                //Procurar as regras
                IList<IRegra> list = new Data.Regra.AnaliseCredito.Regra().Find<IRegra>(where);

                if (list.Count(w => w.GUID != GUID) > 0)
                    throw new FilterAlreadyExists(Convert.ToString(list[0].Descricao));
            }
        }

        /// <summary>
        /// Método para efetuar pesquisa de acordo com o digitado
        /// </summary>
        /// <returns>retorna uma lista de objetos</returns>
        private IList<object[]> Pesquisa()
        {
            try
            {
                Wait.Show();
                IList<object[]> result = null;

                if(_dataSource.IsDynamicPaging)
                {
                    #region sql
                    Where where = new Where();
                    string nome = "";
                    string value = "";
                    string condicao = "";

                    foreach(Control item in grid.Controls
                            .Cast<Control>()
                            .Where(w => w is TextBoxFilter &&
                             !String.IsNullOrEmpty(w.Text)))
                    {

                        TextBoxFilter filter = item as TextBoxFilter;

                        nome = filter.SourceColumn;
                        value = item.Text;
                        Parameter param = PrepareValueToFilter(nome, value, out condicao);
                        where.Add(condicao, param);
                    }

                    _dataSource.ApplyFilters(where);
                    result = DataSource.Values;
                    #endregion
                }
                else
                {
                    #region linq
                    //Começa do valor 1 pois a coluna zero sempre será o GUID
                    int indice = 1;
                    result = DataSource.Values;
                    foreach(TextBoxFilter text in grid.Controls.OfType<TextBoxFilter>())
                    {
                        if(text.Text.Length > 0)
                            result = (from j in result
                                      where VerificaPesquisa(j, text.Text, indice)
                                      select j).ToList();

                        indice++;
                    }
                    #endregion
                }
                return result;
            }
            finally
            {
                Wait.Close();
            }
        }

 /// <summary>
 /// Prepara o comando antes de executar um select
 /// </summary>
 /// <param name="command">comando que será preparado antes da execução</param>
 /// <param name="where">Filtro where adicional</param>
 protected override void PrepareReader(Command command, Where where)
 {
     base.PrepareReader(command, where);
     where.Add("fat_Lan.Tipo", (int)Tipo);
 }

        /// <summary>
        /// Este método vai ser util para filtrar os cadastros de Exportação, pois o mesmo 
        /// não possui uma espcialização e utiliza a mesma FieldDefinition da Leiaute Base.
        /// Então aqui ele vai filtrar somente os especificos de cada leiaute.
        /// </summary>
        protected override void PrepareReader(Command command, Where where)
        {
            base.PrepareReader(command, where);

            where.Add("Importacao", Importacao);
        }

 private void sfModelo_OnSelectedValueChanged(object sender, ComponentModel.SearchField.SelectedItemArgs e)
 {
     sfAnoFabricacao.Enabled = true;
     Where w = new Where();
     w.Add("GUIDModelo", e.GUID);
     sfAnoFabricacao.DataSource = new AnoFabricacao().GetDisplayValues(w);
 }

        /// <summary>
        /// Retorna os lançamentos realizados no caixa informado para o usuário informado.
        /// <para>Se não for informado o caixa ou o usuário, será buscado todos os lançamentos.</para>
        /// </summary>
        /// <param name="caixa">Caixa para pesquisar os lançamentos. Se nulo ou vazio irá trazer todos os caixas</param>
        /// <param name="usuario">Usuário para filtrar os registros somente por ele. Se nulo ou vazio irá trazer para todos os usuários</param>
        /// <param name="status">Status do lançamento. Se informado um valor inválido, não irá filtrar pelo status.</param>
        /// <returns></returns>
        public IList<IContaCorrenteCaixa> Find(ICaixa caixa, IUsuario usuario, StatusLancamento status)
        {
            Where w = new Where();

            if(!caixa.IsNullOrEmpty())
                w.Add("cxa_lancccaixa.guidcaixa", caixa.GUID);

            if(!usuario.IsNullOrEmpty())
                w.Add("cxa_lancccaixa.guidusuariooperador", usuario.GUID);

            if(status.IsValid())
                w.Add("cxa_lancccaixa.statuslancamento", (int)status);

            return new Data.FrenteCaixa.Lancamento.LancamentoCaixa().Find<IContaCorrenteCaixa>(w);
        }