Comment charger un ASP.NET GridView à partir de plusieurs sources de manière asynchrone?

Question

Voici la situation. Je dois frapper environ 50 serveurs et récupérer des données d'un fichier. Je veux ensuite afficher quelques lignes pour chacun dans un contrôle GridView ASP.NET.

J'ai essayé de le faire avec Threads/ThreadPool et rassembler avec succès toutes les données en session. Ce que je voudrais faire, et ce que j'ai du mal à comprendre, c'est mettre à jour la grille pour l'utilisateur après chaque chargement de serveur.

Si je mets le code de liaison de données dans le thread, il n'affichera que ce qui a été chargé au moment où la réponse est renvoyée au client. Si je l'enlève du fil, je devrais attendre que tous les threads aient été envoyés pour envoyer la réponse, et cela ne fait pas ce que je veux.

Vous avez des idées? Je vois des choses sur Asynchronous Client Callbacks, mais je ne suis pas sûr si c'est ce que je dois utiliser. Je n'ai aucune idée de comment manipuler un GridView à partir de Javascript.

Merci pour toute aide que vous pouvez fournir.

Answer 1

Le code ASP.NET côté serveur n'a aucun moyen de percer le navigateur Web et de lui indiquer que de nouvelles données sont disponibles. Vous devrez donc utiliser JavaScript pour interroger le serveur à la recherche de nouvelles données. Il y a plusieurs façons de le faire. Un exemple serait d'utiliser Page Methods sur le serveur qui pourrait dire au client s'il y a plus de données disponibles et quand toutes les données ont été chargées.

[WebMethod] 
public static bool IsNewDataAvailable(int currentClientRows) 
{ 
    return dataCollectedSoFar.Count > currentClientRows; 
} 

[WebMethod] 
public static bool IsFinished() 
{ 
    // return true if all the threads in the thread pool are finished 
} 

Vous devez appeler la méthode IsNewDataAvailable à intervalles réguliers. Une simple minuterie JavaScript devrait faire l'affaire.

Lorsque de nouvelles données sont disponibles, vous devez effectuer un nouveau rendu du GridView. Encore une fois, il y a plus d'une façon de le faire, mais une façon simple et agréable serait de mettre le GridView à l'intérieur d'un UpdatePanel en même temps qu'un bouton avec un style = "display: none;" attribuer pour le garder caché. Ensuite, s'il y a de nouvelles données disponibles, il suffit d'appeler la méthode de clic JavaScript sur le bouton pour mettre à jour le contenu du panneau de mise à jour.

<script> 
var timerId = setInterval("checkForData()", 5000); 

function checkForData() { 

    // If all threads have finished, stop polling 
    if (PageMethods.IsFinished()) { 
     clearInterval(timerId); 
    } 

    var currentRowCount = 0; 

    // Find out how many rows you currently have, if 
    // you have jQuery you could do something like this 
    currentRowCount = $("#<%= myGridView.ClientID %> tr").length; 

    if (PageMethods.IsNewDataAvailable(currentRowCount)) { 

     // Here we trigger the hidden button's click method, again 
     // using a bit of jQuery to show how it might be done 
     $("#<%= myHiddenButton.ClientID %>").click(); 
    } 
} 
</script> 

. . . 

<asp:UpdatePanel ID="myUpdatePanel" runat="server"> 
    <ContentTemplate> 
     <asp:GridView ID="myGridView" runat="server"> 
      . . . 
     </asp:GridView> 
     <asp:Button ID="myHiddenButton" runat="server" style="display: none;" OnClientClick="myHiddenButton_Click" /> 
    </ContentTemplate> 
</asp:UpdatePanel> 

Enfin, pour alimenter le GridView du côté du serveur, vous pouvez continuer à utiliser un ThreadPool et juste rendre toutes les données que vous avez à chaque fois. Par exemple:

protected void myHiddenButton_Click(object sender, EventArgs e) 
{ 
    myGridView.DataSource = dataCollectedSoFar; 
    myGridView.DataBind(); 
} 

Answer 2

J'utilise si rarement les contrôles ASP.net, donc j'ai du mal à y répondre. Je dirais que j'utiliserais Ajax pour indiquer au client quand recharger le Gridview après que les données de chaque serveur aient été récupérées.

J'ai lu un peu à propos de quelque chose appelé active widgets, qui remplacerait votre gridview.

Voici comment je gérerais ceci: Lors de la construction initiale, fournissez un mécanisme d'événement qui est déclenché sur la tâche de chargement de chaque serveur et qui stockerait les résultats dans la session. Côté client, maintenez une mise à jour de l'objet de mise à jour tant que toutes les requêtes du serveur ne sont pas terminées. Un bon format de données pour cela serait JSON.

En tout cas, j'espère que cela a aidé.

Answer 3

Vous pouvez utiliser simplement gridview dans un UpdatePanel et gérer vos callbacks côté client à partir de là, ce qui est probablement l'implémentation la plus simple pour le gridview. Fondamentalement, vous suffit d'envelopper le gridview avec un panneau de mise à jour et tout ce qui est à l'intérieur fonctionnera en utilisant ajax. C'est à vous d'écrire du code efficace pour interroger vos données, mais l'interface utilisateur devrait être plus facile.

Vous pouvez tout faire manuellement avec Javascript et JSON et un service web client mais j'essayerais d'abord le panneau de mise à jour.

Answer 4

load_Click protected void (object sender, EventArgs e) { sqc.ConnectionString = dbc.sqlconn(); sqc.Open(); OleDbCommand cmd = new OleDbCommand ("SELECT cus_serial, nom_cus, cus_mobile, no_person, unit_cost, total_cost de la réservation", sqc); // OleDbDataAdapter adapter = new OleDbDataAdapter (cmd);

sdr = cmd.ExecuteReader(); 
    DataTable dt = new DataTable("A"); 
    dt.Load(sdr); 
    GridView1.DataSource = dt; 
    GridView1.DataBind(); 
    sdr.Close(); 
    sqc.Close(); 
}