GARANTIR DESCONTO

Fórum SQLQuey DataSetProvider ClientDataSet runtime #332570

02/11/2006

0

Delphi

Senhores,

Um determinado formulário, estou querendo criar uma consulta que será usada em várias programas que eu tenho. Analisando o meu código decide que seria interessante criar a consulta criando os componentes em tempo de execução conforme o código abaixo:

procedure TForm1.BitBtn1Click(Sender: TObject);
Var
QryDados : TSQLQuery;
Dsp : TDataSetProvider;
Cds : TClientDataSet;
Ds : TDataSource;
Begin
QryDados:=TSQLQuery.Create(Self);
Dsp:=TDataSetProvider.Create(Self);
Cds:=TClientDataSet.Create(Self);
Ds:=TDataSource.Create(Self);
With QryDados Do
Begin
SQLConnection:=SQLConnection1;
SQL.Add(´Select CODMAT,DESCRICAO,UNID,VALOR From TB_MATERIAL´);
SQL.Add(´Where TIPO=´+QuotedStr(´F´));
SQL.Add(´Order By DESCRICAO´);
End;
Dsp.DataSet:=QryDados;
Cds.ProviderName:=´Dsp´;
Cds.Open;
Ds.DataSet:=Cds;
DBGrid1.DataSource:=Ds;
end;

Mesmo eu informando o datasetprovider na propriedade do clientdataset, quando eu tento abri-lo dá seguinte mensagem: MISSING DATA PROVIDER OR DATASET PACKET.

Alguém já precisou fazer isso? Acredito que estou fazendo o procedimento correto. Alguém poderá me dar uma dica?


Chmeireles

Chmeireles

Responder

Posts

02/11/2006

Richardsonlourenco

Olá Cara!!

Eu só trabalha exatamente assim cara! Acho mias dinâmico e rápido.

Uso duas funções em conjunto:

function AbreQuery( atAlias, atSql: String ): TClientDataSet;
var
   Query     : TSQLDataSet;
   Provider  : TProvider;
   Client    : TClientDataSet;

   {Criando os Componentes para Conexão da Tabela}
   procedure CriaComponentesConexao;
   begin
      {Criando os Componentes}
      {-> SQLQuery}
      Query                := TSQLDataSet.Create( DM );
      Query.Name           := ´qrsds´ + atAlias;
      Query.MaxBlobSize    := -1;
      Query.CommandType    := ctQuery;
      Query.CommandText    := atSql;
      Query.Params.Clear;

      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;


onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim:

cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );


e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso:


procedure FechaQuery( atAlias: String );
var
   cNome: string;
   cComponente: TComponent;
begin
   {-> ClientDataSet}
   cNome       := ´qrcds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
   begin
     (cComponente as TClientDataSet).Close;
     FreeAndNil(cComponente);
   end;

   {-> Provider}
   cNome       := ´qrdsp´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then¬0}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;


onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim:

cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );


e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso:


procedure FechaQuery( atAlias: String );
var
   cNome: string;
   cComponente: TComponent;
begin
   {-> ClientDataSet}
   cNome       := ´qrcds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
   begin
     (cComponente as TClientDataSet).Close;
     FreeAndNil(cComponente);
   end;

   {-> Provider}
   cNome       := ´qrdsp´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
     FreeAndNil(cComponente);

   {-> SQLQuery}
   cNome       := ´qrsds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
     FreeAndNil(cComponente);
end;



no caso do exemplo acima

FechaQuery( cAlias )


Espero ter ajudado:


Responder

Gostei + 0

02/11/2006

Richardsonlourenco

Houve uma ´repetiçãozinha´ de linhas aí mas acho q vai dar para vc entender....

É simples: Existe uma função para criar os compoenetes e outra para destruir


Responder

Gostei + 0

02/11/2006

Chmeireles

Olá Richard,

Entendi sim. Vou fazer um teste no programa com base na rotina que você me mandou, mas gostaria de tirar um pequena dúvida. Prá que ser o comando FreeAndNil?

Muito obrigado pela sua ajuda.


Olá Cara!! Eu só trabalha exatamente assim cara! Acho mias dinâmico e rápido. Uso duas funções em conjunto: 
function AbreQuery( atAlias, atSql: String ): TClientDataSet;
var
   Query     : TSQLDataSet;
   Provider  : TProvider;
   Client    : TClientDataSet;

   {Criando os Componentes para Conexão da Tabela}
   procedure CriaComponentesConexao;
   begin
      {Criando os Componentes}
      {-> SQLQuery}
      Query                := TSQLDataSet.Create( DM );
      Query.Name           := ´qrsds´ + atAlias;
      Query.MaxBlobSize    := -1;
      Query.CommandType    := ctQuery;
      Query.CommandText    := atSql;
      Query.Params.Clear;

      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery¬D atSql;
      Query.Params.Clear;
¬0     {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery¬D atSql;
      Query.Params.Clear;

¬0     {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery¬D atSql;
      Query.Params.Clear;
A¬0     {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery¬D atSql;
      Query.Params.Clear;

      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery( atAlias: String );
var
   cNom
      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery( atAlias: String );
var
   cNome: A      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery( atAlias: String );
var
   cNome: A      {-> Provider}
      Provider             := TProvider.Create( DM );
      Provider.Name        := ´qrdsp´ + atAlias;
      {-> ClientDataSet}
      Client               := TClientDataSet.Create( DM );
      Client.Name          := ´qrcds´ + atAlias;
      Client.Aggregates.Clear;
      Client.Params.Clear;

      {Linkando os Componentes}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery( atAlias: String );
var
   cNome: string;
   cComponente: TComponent;
begin
   {-> ClientDataSet}
   cNome       := ´qrcds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
   begin
     (cComponente as TClientDataSet).Close;
     FreeAndNil(cComponente);
   end;

   {-> Provider}
   cNome       := ´qrdsp´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then¬0}
      Query.SQLConnection  := DM.sqlConexao;
      Provider.DataSet     := Query;
      Client.ProviderName  := Provider.name;
   end;

begin
   CriaComponentesConexao;

   try
      Client.Open;
      Result := Client;
   except
      Result := nil;
   end;
end;
onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa28 atAlias: String ); var cNome: string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa28 atAlias: String ); var cNome: string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa28 atAlias: String ); var cNome: string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa28 atAlias: String ); var cNome: string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu use: string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso:¬string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu o:¬string; cComponente: TComponent; begin {-> ClientDataSet} cNome := ´qrcds´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then begin (cComponente as TClientDataSet).Close; FreeAndNil(cComponente); end; {-> Provider} cNome := ´qrdsp´ + atAlias; cComponente := DM.FindComponent(cNome); if cComponente <> nil then¬0} Query.SQLConnection := DM.sqlConexao; Provider.DataSet := Query; Client.ProviderName := Provider.name; end; begin CriaComponentesConexao; try Client.Open; Result := Client; except Result := nil; end; end;[/code] onde essa retorna um TClientDataSet que posso associar diretamente com o meu datasource assim: 
cAlias    := ´SGPRO´;
cSql     := ´SELECT * from SGPRO´;

dtsPrincipal.DataSet    := AbreQuery( cAlias, cSql );
e no fim de todo o prcesso para fechar essa query eliminando todos os seus componentes eu uso: 
procedure FechaQuery( atAlias: String );
var
   cNome: string;
   cComponente: TComponent;
begin
   {-> ClientDataSet}
   cNome       := ´qrcds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
   begin
     (cComponente as TClientDataSet).Close;
     FreeAndNil(cComponente);
   end;

   {-> Provider}
   cNome       := ´qrdsp´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
     FreeAndNil(cComponente);

   {-> SQLQuery}
   cNome       := ´qrsds´ + atAlias;
   cComponente := DM.FindComponent(cNome);
   if cComponente <> nil then
     FreeAndNil(cComponente);
end;
no caso do exemplo acima 
FechaQuery( cAlias )
Espero ter ajudado:



Responder

Gostei + 0

02/11/2006

Richardsonlourenco

O comando FreeAndNil serva para vc liberar o objeto da memoria e atribuir a sua alocação o valo Nil.


Responder

Gostei + 0

29/01/2007

Chmeireles

Olá

Você me deu uma grande ajuda no ano passado me explicando como manipular o trio de componentes SQLQuery+DataSetProvier + ClientDataSet runtime. Com a sua ajuda eu consegui implantar essa metodologia aqui na empresa. Mas eu esbarrei em um problema. Existe cadastrados que fazem consultas em campos externos. Veja o código SQL abaixo:

Select A.CODMAT,A.DESCRICAO,A.UNID,A.FAMILIA,B.DESCRICAO as DESC_FAMILIA
From TB_MATERIAL A
Left Outer Join TB_FAMILIA_MATERIAL B
On (B.FAMILIA=A.FAMILIA)
Order BY A.DESCRICAO

Nesse caso quando o usuário abre a tela de cadastro de material o programa traz automaticamente a descrição da familia que esta associada ao material. Agora eu dou um APPLYUPDATES dá o seguinte erro COLUMN UNKNOWN AT LINE 8 COLUMN 15. Isso acontece que o datasetprovider está tentando atualizar o campo DESCRICAO da tabela TB_FAMILIA_MATERIAL. Quando eu fazia em tempo de design eu utilizava a propriedade providerflags, assim esse não acontecia já que esse campo está sendo indicado que não receberia nenhum tipo de atualização, como farei isso agora já que os campos não são carregados?

Agradeço desde já pela sua ajuda,


Responder

Gostei + 0

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar