Tri GridView: SortDirection toujours croissant
J'ai un gridview et je dois trier ses éléments lorsque l'utilisateur clique sur l'en-tête.
Sa source de données est un objet List.
L'aspx est défini comme suit:
<asp:GridView ID="grdHeader" AllowSorting="true" AllowPaging="false"
AutoGenerateColumns="false" Width="780" runat="server" OnSorting="grdHeader_OnSorting" EnableViewState="true">
<Columns>
<asp:BoundField DataField="Entitycode" HeaderText="Entity" SortExpression="Entitycode" />
<asp:BoundField DataField="Statusname" HeaderText="Status" SortExpression="Statusname" />
<asp:BoundField DataField="Username" HeaderText="User" SortExpression="Username" />
</Columns>
</asp:GridView>
Le code derrière est défini comme suit:
Premier chargement:
protected void btnSearch_Click(object sender, EventArgs e)
{
List<V_ReportPeriodStatusEntity> items = GetPeriodStatusesForScreenSelection();
this.grdHeader.DataSource = items;
this.grdHeader.DataBind();
}
lorsque l'utilisateur clique sur les en-têtes:
protected void grdHeader_OnSorting(object sender, GridViewSortEventArgs e)
{
List<V_ReportPeriodStatusEntity> items = GetPeriodStatusesForScreenSelection();
items.Sort(new Helpers.GenericComparer<V_ReportPeriodStatusEntity>(e.SortExpression, e.SortDirection));
grdHeader.DataSource = items;
grdHeader.DataBind();
}
Mon problème est que e.SortDirection est toujours défini sur Ascending.
J'ai une page Web avec un code similaire et cela fonctionne bien, e.SortDirection alterne entre croissant et décroissant.
Qu'ai-je fait de mal ?
Vous pouvez utiliser une variable de session pour stocker la dernière expression de tri et lors de votre prochain tri de la grille, comparez-la à la variable de session qui stocke la dernière expression de tri. Si les colonnes sont égales, vérifiez la direction du tri précédent et triez dans le sens opposé.
Exemple:
DataTable sourceTable = GridAttendence.DataSource as DataTable;
DataView view = new DataView(sourceTable);
string[] sortData = Session["sortExpression"].ToString().Trim().Split(' ');
if (e.SortExpression == sortData[0])
{
if (sortData[1] == "ASC")
{
view.Sort = e.SortExpression + " " + "DESC";
this.ViewState["sortExpression"] = e.SortExpression + " " + "DESC";
}
else
{
view.Sort = e.SortExpression + " " + "ASC";
this.ViewState["sortExpression"] = e.SortExpression + " " + "ASC";
}
}
else
{
view.Sort = e.SortExpression + " " + "ASC";
this.ViewState["sortExpression"] = e.SortExpression + " " + "ASC";
}
Le problème avec Session et Viewstate est que vous devez également garder une trace du contrôle gridview pour lequel SortColumn et Direction est stocké s'il existe plusieurs vues gridview sur la page.
Une alternative à Session et Viewstate consiste à ajouter 2 attributs à Gridview et à garder une trace de Column et Direction de cette manière.
Voici un exemple:
private void GridViewSortDirection(GridView g, GridViewSortEventArgs e, out SortDirection d, out string f)
{
f = e.SortExpression;
d = e.SortDirection;
//Check if GridView control has required Attributes
if (g.Attributes["CurrentSortField"] != null && g.Attributes["CurrentSortDir"] != null)
{
if (f == g.Attributes["CurrentSortField"])
{
d = SortDirection.Descending;
if (g.Attributes["CurrentSortDir"] == "ASC")
{
d = SortDirection.Ascending;
}
}
g.Attributes["CurrentSortField"] = f;
g.Attributes["CurrentSortDir"] = (d == SortDirection.Ascending ? "DESC" : "ASC");
}
}
Une solution simple:
protected SortDirection GetSortDirection(string column)
{
SortDirection nextDir = SortDirection.Ascending; // Default next sort expression behaviour.
if (ViewState["sort"] != null && ViewState["sort"].ToString() == column)
{ // Exists... DESC.
nextDir = SortDirection.Descending;
ViewState["sort"] = null;
}
else
{ // Doesn't exists, set ViewState.
ViewState["sort"] = column;
}
return nextDir;
}
Tout comme le tri par défaut GridView et léger sur ViewState.
UTILISATION:
protected void grdHeader_OnSorting(object sender, GridViewSortEventArgs e)
{
List<V_ReportPeriodStatusEntity> items = GetPeriodStatusesForScreenSelection();
items.Sort(new Helpers.GenericComparer<V_ReportPeriodStatusEntity>(e.SortExpression, GetSortDirection(e.SortExpression));
grdHeader.DataSource = items;
grdHeader.DataBind();
}
Le tri bidirectionnel automatique ne fonctionne qu'avec la source de données SQL. Malheureusement, toute la documentation de MSDN suppose que vous l'utilisez, donc GridView peut devenir un peu frustrant.
Pour ce faire, je surveille moi-même l'ordre. Par exemple:
protected void OnSortingResults(object sender, GridViewSortEventArgs e)
{
// If we're toggling sort on the same column, we simply toggle the direction. Otherwise, ASC it is.
// e.SortDirection is useless and unreliable (only works with SQL data source).
if (_sortBy == e.SortExpression)
_sortDirection = _sortDirection == SortDirection.Descending ? SortDirection.Ascending : SortDirection.Descending;
else
_sortDirection = SortDirection.Ascending;
_sortBy = e.SortExpression;
BindResults();
}
Ce problème est absent non seulement avec les sources de données SQL, mais également avec les sources de données objet. Cependant, lors de la définition dynamique de la source de données dans le code, c'est à ce moment-là que tout va mal. Malheureusement, MSDN est parfois vraiment très pauvre en information. Une simple mention de ce comportement (il ne s'agit pas d'un bogue, mais d'un problème de conception) permettrait de gagner beaucoup de temps. Quoi qu'il en soit, je ne suis pas très enclin à utiliser les variables de session pour cela. Je stocke généralement le sens du tri dans un ViewState.
La façon dont je l'ai fait est similaire au code que le accepté la réponse fourni, est un peu différent, donc j'ai pensé que je le publierais aussi. Notez que ce tri est effectué sur un DataTable avant de le lier au GridView . DataSource.
Option 1: Utiliser ViewState
void DataGrid_Sorting(object sender, GridViewSortEventArgs e)
{
if (e.SortExpression == (string)ViewState["SortColumn"])
{
// We are resorting the same column, so flip the sort direction
e.SortDirection =
((SortDirection)ViewState["SortColumnDirection"] == SortDirection.Ascending) ?
SortDirection.Descending : SortDirection.Ascending;
}
// Apply the sort
this._data.DefaultView.Sort = e.SortExpression +
(string)((e.SortDirection == SortDirection.Ascending) ? " ASC" : " DESC");
ViewState["SortColumn"] = e.SortExpression;
ViewState["SortColumnDirection"] = e.SortDirection;
}
Deuxième option: Utiliser la session
Notez que les éléments suivants sont fournis à des fins héritées au cas où vous les voyez sur le terrain ou que vous preniez toujours en charge des systèmes de société ciblant des navigateurs plus anciens.
void DataGrid_Sorting(object sender, GridViewSortEventArgs e)
{
if (e.SortExpression == (string)HttpContext.Current.Session["SortColumn"])
{
// We are resorting the same column, so flip the sort direction
e.SortDirection =
((SortDirection)HttpContext.Current.Session["SortColumnDirection"] == SortDirection.Ascending) ?
SortDirection.Descending : SortDirection.Ascending;
}
// Apply the sort
this._data.DefaultView.Sort = e.SortExpression +
(string)((e.SortDirection == SortDirection.Ascending) ? " ASC" : " DESC");
HttpContext.Current.Session["SortColumn"] = e.SortExpression;
HttpContext.Current.Session["SortColumnDirection"] = e.SortDirection;
}
Je ne sais pas pourquoi tout le monde oublie d'utiliser des champs cachés! Ils sont tellement "moins chers" que ViewState (que j'ai éteint depuis 2005). Si vous ne souhaitez pas utiliser Session ou ViewState, voici ma solution:
Mettez ces deux champs cachés sur votre page aspx, et mettez le tri par défaut que vous voulez pour vos données (j'utilise LastName par exemple):
<asp:HiddenField ID="hfSortExpression" runat="server" Value="LastName" />
<asp:HiddenField ID="hfSortDirection" runat="server" Value="Ascending" />
Ensuite, mettez ce code d'assistance dans votre page de base (vous avez une page de base, n'est-ce pas? Sinon, insérez votre code .cs derrière).
/// <summary>
/// Since native ASP.Net GridViews do not provide accurate SortDirections,
/// we must save a hidden field with previous sort Direction and Expression.
/// Put these two hidden fields on page and call this method in grid sorting event
/// </summary>
/// <param name="hfSortExpression">The hidden field on page that has the PREVIOUS column that is sorted on</param>
/// <param name="hfSortDirection">The hidden field on page that has the PREVIOUS sort direction</param>
protected SortDirection GetSortDirection(GridViewSortEventArgs e, HiddenField hfSortExpression, HiddenField hfSortDirection)
{
//assume Ascending always by default!!
SortDirection sortDirection = SortDirection.Ascending;
//see what previous column (if any) was sorted on
string previousSortExpression = hfSortExpression.Value;
//see what previous sort direction was used
SortDirection previousSortDirection = !string.IsNullOrEmpty(hfSortDirection.Value) ? ((SortDirection)Enum.Parse(typeof(SortDirection), hfSortDirection.Value)) : SortDirection.Ascending;
//check if we are now sorting on same column
if (e.SortExpression == previousSortExpression)
{
//check if previous direction was ascending
if (previousSortDirection == SortDirection.Ascending)
{
//since column name matches but direction doesn't,
sortDirection = SortDirection.Descending;
}
}
// save them back so you know for next time
hfSortExpression.Value = e.SortExpression;
hfSortDirection.Value = sortDirection.ToString();
return sortDirection;
}
Ensuite, vous devez gérer le tri dans votre gestionnaire d'événements de tri sur la grille. Appelez la méthode ci-dessus à partir du gestionnaire d'événements de tri avant d'appeler votre méthode principale qui récupère vos données.
protected void gridContacts_Sorting(object sender, GridViewSortEventArgs e)
{
//get the sort direction (since GridView sortDirection is not implemented!)
SortDirection sortDirection = GetSortDirection(e, hfSortExpression, hfSortDirection);
//get data, sort and rebind (obviously, this is my own method... you must replace with your own)
GetCases(_accountId, e.SortExpression, sortDirection);
}
Étant donné que de nombreux exemples utilisent DataTables ou DataViews ou d'autres collections non compatibles avec LINQ, j'ai pensé inclure un exemple d'appel à une méthode de niveau intermédiaire renvoyant une liste générique, et d'utiliser LINQ pour effectuer le tri afin de compléter l'exemple et le rendre plus "réel":
private void GetCases(AccountID accountId, string sortExpression, SortDirection sortDirection)
{
//get some data from a middle tier method (database etc._)(
List<PendingCase> pendingCases = MyMiddleTier.GetCasesPending(accountId.Value);
//show a count to the users on page (this is just Nice to have)
lblCountPendingCases.Text = pendingCases.Count.ToString();
//do the actual sorting of your generic list of custom objects
pendingCases = Sort(sortExpression, sortDirection, pendingCases);
//bind your grid
grid.DataSource = pendingCases;
grid.DataBind();
}
Enfin, voici le tri bas et sale utilisant LINQ sur une liste générique d'objets personnalisés. Je suis sûr qu'il y a quelque chose d'amateur qui fera l'affaire, mais cela illustre le concept:
tri de liste statique privé (chaîne sortExpression, SortDirection sortDirection, List pendingCases) {
switch (sortExpression)
{
case "FirstName":
pendingCases = sortDirection == SortDirection.Ascending ? pendingCases.OrderBy(c => c.FirstName).ToList() : pendingCases.OrderByDescending(c => c.FirstName).ToList();
break;
case "LastName":
pendingCases = sortDirection == SortDirection.Ascending ? pendingCases.OrderBy(c => c.LastName).ToList() : pendingCases.OrderByDescending(c => c.LastName).ToList();
break;
case "Title":
pendingCases = sortDirection == SortDirection.Ascending ? pendingCases.OrderBy(c => c.Title).ToList() : pendingCases.OrderByDescending(c => c.Title).ToList();
break;
case "AccountName":
pendingCases = sortDirection == SortDirection.Ascending ? pendingCases.OrderBy(c => c.AccountName).ToList() : pendingCases.OrderByDescending(c => c.AccountName).ToList();
break;
case "CreatedByEmail":
pendingCases = sortDirection == SortDirection.Ascending ? pendingCases.OrderBy(c => c.CreatedByEmail).ToList() : pendingCases.OrderByDescending(c => c.CreatedByEmail).ToList();
break;
default:
break;
}
return pendingCases;
}
Enfin et surtout (ai-je déjà dit cela?), Vous voudrez peut-être insérer quelque chose comme ceci dans votre gestionnaire Page_Load afin que la grille se lie par défaut lors du chargement de la page ... Notez que _accountId est un paramètre de chaîne de requête, converti en un paramètre personnalisé. type de AccountID de mon propre dans ce cas ...
if (!Page.IsPostBack)
{
//sort by LastName ascending by default
GetCases(_accountId,hfSortExpression.Value,SortDirection.Ascending);
}
Un autre :) Pas besoin de coder en dur les noms de colonnes ..
DataTable dt = GetData();
SortDirection sd;
string f;
GridViewSortDirection(gvProductBreakdown, e, out sd, out f);
dt.DefaultView.Sort = sd == SortDirection.Ascending ? f + " asc" : f + " desc";
gvProductBreakdown.DataSource = dt;
gvProductBreakdown.DataBind();
Ant alors:
private void GridViewSortDirection(GridView g, GridViewSortEventArgs e, out SortDirection d, out string f)
{
f = e.SortExpression;
d = e.SortDirection;
if (g.Attributes[f] != null)
{
d = g.Attributes[f] == "ASC" ? SortDirection.Descending : SortDirection.Ascending;
g.Attributes[f] = d == SortDirection.Ascending ? "ASC" : "DESC";
}
else
{
g.Attributes[f] = "ASC";
d = SortDirection.Ascending;
}
Toute cette réponse pas tout à fait correcte. J'utilise ça:
protected void SetPageSort(GridViewSortEventArgs e)
{
if (e.SortExpression == SortExpression)
{
if (SortDirection == "ASC")
{
SortDirection = "DESC";
}
else
{
SortDirection = "ASC";
}
}
else
{
if (SortDirection == "ASC")
{
SortDirection = "DESC";
}
else
{
SortDirection = "ASC";
}
SortExpression = e.SortExpression;
}
}
protected void gridView_Sorting(object sender, GridViewSortEventArgs e)
{
SetPageSort(e);
dans gridView_Sorting ...
Cela peut être fait sans utiliser View State ou Session. L'ordre actuel peut être déterminé en fonction de la valeur dans les première et dernière lignes de la colonne triée par:
protected void gvItems_Sorting(object sender, GridViewSortEventArgs e)
{
GridView grid = sender as GridView; // get reference to grid
SortDirection currentSortDirection = SortDirection.Ascending; // default order
// get column index by SortExpression
int columnIndex = grid.Columns.IndexOf(grid.Columns.OfType<DataControlField>()
.First(x => x.SortExpression == e.SortExpression));
// sort only if grid has more than 1 row
if (grid.Rows.Count > 1)
{
// get cells
TableCell firstCell = grid.Rows[0].Cells[columnIndex];
TableCell lastCell = grid.Rows[grid.Rows.Count - 1].Cells[columnIndex];
// if field type of the cell is 'TemplateField' Text property is always empty.
// Below assumes that value is binded to Label control in 'TemplateField'.
string firstCellValue = firstCell.Controls.Count == 0 ? firstCell.Text : ((Label)firstCell.Controls[1]).Text;
string lastCellValue = lastCell.Controls.Count == 0 ? lastCell.Text : ((Label)lastCell.Controls[1]).Text;
DateTime tmpDate;
decimal tmpDecimal;
// try to determinate cell type to ensure correct ordering
// by date or number
if (DateTime.TryParse(firstCellValue, out tmpDate)) // sort as DateTime
{
currentSortDirection =
DateTime.Compare(Convert.ToDateTime(firstCellValue),
Convert.ToDateTime(lastCellValue)) < 0 ?
SortDirection.Ascending : SortDirection.Descending;
}
else if (Decimal.TryParse(firstCellValue, out tmpDecimal)) // sort as any numeric type
{
currentSortDirection = Decimal.Compare(Convert.ToDecimal(firstCellValue),
Convert.ToDecimal(lastCellValue)) < 0 ?
SortDirection.Ascending : SortDirection.Descending;
}
else // sort as string
{
currentSortDirection = string.CompareOrdinal(firstCellValue, lastCellValue) < 0 ?
SortDirection.Ascending : SortDirection.Descending;
}
}
// then bind GridView using correct sorting direction (in this example I use Linq)
if (currentSortDirection == SortDirection.Descending)
{
grid.DataSource = myItems.OrderBy(x => x.GetType().GetProperty(e.SortExpression).GetValue(x, null));
}
else
{
grid.DataSource = myItems.OrderByDescending(x => x.GetType().GetProperty(e.SortExpression).GetValue(x, null));
}
grid.DataBind();
}
Cela va sans doute être enterré ici, mais la solution que j'ai proposée convient parfaitement à ma situation:
Form Load Event ressemble à ceci:
private DataTable DataTable1;
protected void Page_Load(object sender, EventArgs e)
{
DataTable1 = GetDataFromDatabase();
this.GridView1.DataSource = DataTable1.DefaultView;
this.GridView1.DataBind();
}
Ajoutez deux champs cachés à la page:
<asp:HiddenField runat="server" ID="lastSortDirection" />
<asp:HiddenField runat="server" ID="lastSortExpression" />
Ajoutez ce qui suit à votre objet asp: GridView:
AllowSorting="True" OnSorting="GridView1_Sorting"
Utiliser l'événement de tri GridView suivant
protected void GridView1_Sorting(object sender, GridViewSortEventArgs e)
{
if (lastSortExpression.Value == e.SortExpression.ToString())
{
if (lastSortDirection.Value == SortDirection.Ascending.ToString())
{
e.SortDirection = SortDirection.Descending;
}
else
{
e.SortDirection = SortDirection.Ascending;
}
lastSortDirection.Value = e.SortDirection.ToString();
lastSortExpression.Value = e.SortExpression;
}
else
{
lastSortExpression.Value = e.SortExpression;
e.SortDirection = SortDirection.Ascending;
lastSortDirection.Value = e.SortDirection.ToString();
}
DataView dv = DataTable1.DefaultView;
if (e.SortDirection == SortDirection.Ascending)
{
dv.Sort = e.SortExpression;
}
else
{
dv.Sort = e.SortExpression + " DESC";
}
DataTable1 = dv.ToTable();
GridView1.DataSource = DataTable1.DefaultView;
GridView1.DataBind();
}
Désormais, toutes les colonnes de ma grille sont triées sans nécessiter d'autres modifications si l'une des colonnes change.
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="false" AllowSorting="True"
onsorting="GridView1_Sorting" EnableViewState="true">
<Columns><asp:BoundField DataField="bookid" HeaderText="BOOK ID" SortExpression="bookid" />
<asp:BoundField DataField="bookname" HeaderText="BOOK NAME" />
<asp:BoundField DataField="writer" HeaderText="WRITER" />
<asp:BoundField DataField="totalbook" HeaderText="TOTAL BOOK" SortExpression="totalbook" />
<asp:BoundField DataField="availablebook" HeaderText="AVAILABLE BOOK" />
//gridview code on page load under ispostback false//after that.
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
string query = "SELECT * FROM book";
DataTable DT = new DataTable();
SqlDataAdapter DA = new SqlDataAdapter(query, sqlCon);
DA.Fill(DT);
GridView1.DataSource = DT;
GridView1.DataBind();
}
}
protected void GridView1_Sorting(object sender, GridViewSortEventArgs e)
{
string query = "SELECT * FROM book";
DataTable DT = new DataTable();
SqlDataAdapter DA = new SqlDataAdapter(query, sqlCon);
DA.Fill(DT);
GridView1.DataSource = DT;
GridView1.DataBind();
if (DT != null)
{
DataView dataView = new DataView(DT);
dataView.Sort = e.SortExpression + " " + ConvertSortDirectionToSql(e.SortDirection);
GridView1.DataSource = dataView;
GridView1.DataBind();
}
}
private string GridViewSortDirection
{
get { return ViewState["SortDirection"] as string ?? "DESC"; }
set { ViewState["SortDirection"] = value; }
}
private string ConvertSortDirectionToSql(SortDirection sortDirection)
{
switch (GridViewSortDirection)
{
case "ASC":
GridViewSortDirection = "DESC";
break;
case "DESC":
GridViewSortDirection = "ASC";
break;
}
return GridViewSortDirection;
}
}
J'en avais marre de traiter de cette question et j'ai mis la direction et la colonne de tri dans ViewState ...
Vieille ficelle, mais peut-être que ma réponse aidera quelqu'un.
Commencez par obtenir votre SqlDataSource en tant que DataView:
Private Sub DataGrid1_SortCommand(ByVal source As Object, ByVal e As DataGridSortCommandEventArgs) Handles grid1.SortCommand
Dim dataView As DataView = CType(SqlDataSource1.Select(DataSourceSelectArguments.Empty), DataView)
dataView.Sort = e.SortExpression + dataView.FieldSortDirection(Session, e.SortExpression)
grid1.DataSourceID = Nothing
grid1.DataSource = dataView
grid1.DataBind()
End Sub
Ensuite, utilisez une méthode d’extension pour le tri (genre de tir positif, mais bon début):
public static class DataViewExtensions
{
public static string FieldSortDirection(this DataView dataView, HttpSessionState session, string sortExpression)
{
const string SORT_DIRECTION = "SortDirection";
var identifier = SORT_DIRECTION + sortExpression;
if (session[identifier] != null)
{
if ((string) session[identifier] == " ASC")
session[identifier] = " DESC";
else if ((string) session[identifier] == " DESC")
session[identifier] = " ASC";
}
else
session[identifier] = " ASC";
return (string) session[identifier];
}
}
Pour basculer en ordre croissant ou décroissant, j'utilise une méthode dans BasePage de mon application pour mettre en cache l'expression et le sens du tri:
protected void SetPageSort(GridViewSortEventArgs e)
{
if (e.SortExpression == SortExpression)
{
if (SortDirection == "ASC")
{
SortDirection = "DESC";
}
else
{
SortDirection = "ASC";
}
}
else
{
SortDirection = "ASC";
SortExpression = e.SortExpression;
}
}
SortExpression et SortDirection sont deux propriétés de BasePage qui stockent et extraient leurs valeurs de ViewState.
Ainsi, toutes mes pages dérivées appellent simplement SetPageSort à partir de la méthode de tri de GridView et lient GridView:
protected void gv_Sorting(object sender, GridViewSortEventArgs e)
{
SetPageSort(e);
BindGrid();
}
BindGrid vérifie le SortExpression et l'utilise avec SortDirection pour effectuer un ORDERY BY sur la source de données de la grille, à peu près comme ceci:
if (SortExpression.Length > 0)
{
qry.ORDER_BY(SortExpression + " " + SortDirection);
}
gv.DataSource = qry.ExecuteReader();
gv.DataBind();
Ainsi, la classe de base 'SetPageSort supprime une grande partie des tâches fastidieuses du tri GridView. J'ai l'impression d'oublier quelque chose, mais c'est l'idée générale.
XML:
<asp:BoundField DataField="DealCRMID" HeaderText="Opportunity ID"
SortExpression="DealCRMID"/>
<asp:BoundField DataField="DealCustomerName" HeaderText="Customer"
SortExpression="DealCustomerName"/>
<asp:BoundField DataField="SLCode" HeaderText="Practice"
SortExpression="SLCode"/>
Code:
private string ConvertSortDirectionToSql(String sortExpression,SortDirection sortDireciton)
{
switch (sortExpression)
{
case "DealCRMID":
ViewState["DealCRMID"]=ChangeSortDirection(ViewState["DealCRMID"].ToString());
return ViewState["DealCRMID"].ToString();
case "DealCustomerName":
ViewState["DealCustomerName"] = ChangeSortDirection(ViewState["DealCustomerName"].ToString());
return ViewState["DealCustomerName"].ToString();
case "SLCode":
ViewState["SLCode"] = ChangeSortDirection(ViewState["SLCode"].ToString());
return ViewState["SLCode"].ToString();
default:
return "ASC";
}
}
private string ChangeSortDirection(string sortDireciton)
{
switch (sortDireciton)
{
case "DESC":
return "ASC";
case "ASC":
return "DESC";
default:
return "ASC";
}
}
protected void gvPendingApprovals_Sorting(object sender, GridViewSortEventArgs e)
{
DataSet ds = (System.Data.DataSet)(gvPendingApprovals.DataSource);
if(ds.Tables.Count>0)
{
DataView m_DataView = new DataView(ds.Tables[0]);
m_DataView.Sort = e.SortExpression + " " + ConvertSortDirectionToSql (e.SortExpression.ToString(), e.SortDirection);
gvPendingApprovals.DataSource = m_DataView;
gvPendingApprovals.DataBind();
}
}
Utilisation de la solution SecretSquirrel ci-dessus
voici mon code de production complet. Changez simplement dgvCoaches en votre nom de vue de grille.
... lors de la reliure de la grille
dgvCoaches.DataSource = dsCoaches.Tables[0];
ViewState["AllCoaches"] = dsCoaches.Tables[0];
dgvCoaches.DataBind();
et maintenant le tri
protected void gridView_Sorting(object sender, GridViewSortEventArgs e)
{
DataTable dt = ViewState["AllCoaches"] as DataTable;
if (dt != null)
{
if (e.SortExpression == (string)ViewState["SortColumn"])
{
// We are resorting the same column, so flip the sort direction
e.SortDirection =
((SortDirection)ViewState["SortColumnDirection"] == SortDirection.Ascending) ?
SortDirection.Descending : SortDirection.Ascending;
}
// Apply the sort
dt.DefaultView.Sort = e.SortExpression +
(string)((e.SortDirection == SortDirection.Ascending) ? " ASC" : " DESC");
ViewState["SortColumn"] = e.SortExpression;
ViewState["SortColumnDirection"] = e.SortDirection;
dgvCoaches.DataSource = dt;
dgvCoaches.DataBind();
}
}
et voici le code aspx:
<asp:GridView ID="dgvCoaches" runat="server"
CssClass="table table-hover table-striped" GridLines="None" DataKeyNames="HealthCoachID" OnRowCommand="dgvCoaches_RowCommand"
AutoGenerateColumns="False" OnSorting="gridView_Sorting" AllowSorting="true">
<Columns>
<asp:BoundField DataField="HealthCoachID" Visible="false" />
<asp:BoundField DataField="LastName" HeaderText="Last Name" SortExpression="LastName" />
<asp:BoundField DataField="FirstName" HeaderText="First Name" SortExpression="FirstName" />
<asp:BoundField DataField="LoginName" HeaderText="Login Name" SortExpression="LoginName" />
<asp:BoundField DataField="Email" HeaderText="Email" SortExpression="Email" HtmlEncode="false" DataFormatString="<a href=mailto:{0}>{0}</a>" />
<asp:TemplateField>
<ItemTemplate>
<asp:LinkButton runat="server" BorderStyle="None" CssClass="btn btn-default" Text="<i class='glyphicon glyphicon-edit'></i>" CommandName="Update" CommandArgument="<%# ((GridViewRow) Container).RowIndex %>" />
</ItemTemplate>
</asp:TemplateField>
<asp:TemplateField>
<ItemTemplate>
<asp:LinkButton runat="server" OnClientClick="return ConfirmOnDelete();" BorderStyle="None" CssClass="btn btn-default" Text="<i class='glyphicon glyphicon-remove'></i>" CommandName="Delete" CommandArgument="<%# ((GridViewRow) Container).RowIndex %>" />
</ItemTemplate>
</asp:TemplateField>
</Columns>
<RowStyle CssClass="cursor-pointer" />
</asp:GridView>
Cela fait longtemps que je n'ai pas utilisé GridView, mais je pense que vous devez définir la propriété SortDirection de la grille sur ce qu'elle est actuellement avant de quitter la méthode OnSorting.
Alors....
List<V_ReportPeriodStatusEntity> items = GetPeriodStatusesForScreenSelection();items.Sort(new Helpers.GenericComparer<V_ReportPeriodStatusEntity>(e.SortExpression, e.SortDirection));grdHeader.SortDirection = e.SortDirection.Equals(SortDirection.Ascending) ? SortDirection.Descending : SortDirection.Ascending;grdHeader.DataSource = items;grdHeader.DataBind();
C'est une autre façon de résoudre le problème:
protected void grdHeader_OnSorting(object sender, GridViewSortEventArgs e)
{
List<V_ReportPeriodStatusEntity> items = GetPeriodStatusesForScreenSelection();
items.Sort = e.SortExpression + " " + ConvertSortDirectionToSql(e);
grdHeader.DataSource = items;
grdHeader.DataBind();
}
private string ConvertSortDirectionToSql(GridViewSortEventArgs e)
{
ViewState[e.SortExpression] = ViewState[e.SortExpression] ?? "ASC";
ViewState[e.SortExpression] = (ViewState[e.SortExpression].ToString() == "ASC") ? "DESC" : "ASC";
return ViewState[e.SortExpression].ToString();
}
J'ai eu un horrible problème avec cela, alors j'ai finalement utilisé LINQ pour commander le DataTable avant de l'assigner à la vue:
Dim lquery = From s In listToMap
Select s
Order By s.ACCT_Active Descending, s.ACCT_Name
En particulier, j'ai trouvé les méthodes DataView.Sort et DataGrid.Sort peu fiables lors du tri d'un champ booléen.
J'espère que cela aide quelqu'un là-bas.
A écrit ceci, cela fonctionne pour moi:
protected void GridView1_Sorting(object sender, GridViewSortEventArgs e)
{
if (ViewState["sortExpression"] == null || ViewState["sortExpression"].ToString() != e.SortExpression.ToString())
MyDataTable.DefaultView.Sort = e.SortExpression + " ASC";
else
{
if (ViewState["SortDirection"].ToString() == "Ascending")
MyDataTable.DefaultView.Sort = e.SortExpression = e.SortExpression + " DESC";
else
MyDataTable.DefaultView.Sort = e.SortExpression + " ASC";
}
GridView1.DataSource = MyDataTable;
GridView1.DataBind();
ViewState["sortExpression"] = e.SortExpression;
ViewState["SortDirection"] = e.SortDirection;
}
void dg_SortCommand(object source, DataGridSortCommandEventArgs e)
{
DataGrid dg = (DataGrid) source;
string sortField = dg.Attributes["sortField"];
List < SubreportSummary > data = (List < SubreportSummary > ) dg.DataSource;
string field = e.SortExpression.Split(' ')[0];
string sort = "ASC";
if (sortField != null)
{
sort = sortField.Split(' ')[0] == field ? (sortField.Split(' ')[1] == "DESC" ? "ASC" : "DESC") : "ASC";
}
dg.Attributes["sortField"] = field + " " + sort;
data.Sort(new GenericComparer < SubreportSummary > (field, sort, null));
dg.DataSource = data;
dg.DataBind();
}
Cela aidera peut-être quelqu'un. Je ne sais pas si c'est parce que nous sommes en 2014 ou si je ne comprends pas le problème que cette publication tente de résoudre, mais c'est très simple avec slickgrid, comme suit:
Le problème semble être de savoir comment «se souvenir» du paramètre de tri actuel afin que Asp.Net conserve cette valeur pour vous. Cependant, slickGrid peut vous dire quel est l’ordre de tri actuel:
Pour basculer le tri croissant, vous pouvez utiliser grid.getSortColumns () pour connaître le type de tri de la colonne. C’est ce que j’ai fait mais je ne fais que trier 1 colonne à la fois et je peux donc le faire en toute sécurité: 'if (grid.getSortColumns () [0] .sortAsc)'
... donc mon code qui fonctionne est comme ceci:
// Make sure you have sortable: true on the relevant column names or
// nothing happens as I found!!
var columns = [
{ name: "FileName", id: "FileName", field: "FileName", width: 95, selectable: true, sortable: true },
{ name: "Type", id: "DocumentType", field: "DocumentType", minWidth: 105, width: 120, maxWidth: 120, selectable: true, sortable: true },
{ name: "ScanDate", id: "ScanDate", field: "ScanDate", width: 90, selectable: true, sortable: true }, ];
.. chargez vos données comme d'habitude puis la partie sort:
// Clicking on a column header fires this event. Here we toggle the sort direction
grid.onHeaderClick.subscribe(function(e, args) {
var columnID = args.column.id;
if (grid.getSortColumns()[0].sortAsc) {
grid.setSortColumn(args.column.id, true);
}
else {
grid.setSortColumn(args.column.id, false);
}
});
// The actual sort function is like this
grid.onSort.subscribe(function (e, args) {
sortdir = args.sortAsc ? 1 : -1;
sortcol = args.sortCol.field;
//alert('in sort');
// using native sort with comparer
// preferred method but can be very slow in IE with huge datasets
dataView.sort(comparer, args.sortAsc);
grid.invalidateAllRows();
grid.render();
});
// Default comparer is enough for what I'm doing here ..
function comparer(a, b) {
var x = a[sortcol], y = b[sortcol];
return (x == y ? 0 : (x > y ? 1 : -1));
}
Enfin, assurez-vous que le dossier d’images SlickGrid est inclus dans votre site et que les flèches asc/desc apparaissent dans la colonne lorsque vous le sélectionnez. S'ils manquent, le texte ira en italique mais aucune flèche n'apparaîtra.
Voici comment je fais. Beaucoup plus facile que beaucoup de réponses ici, IMO:
Créer cette classe SortDirection
// ==================================================
// SortByDirection
// ==================================================
public SortDirection SortByDirection
{
get
{
if (ViewState["SortByDirection"] == null)
{
ViewState["SortByDirection"] = SortDirection.Ascending;
}
return (SortDirection)Enum.Parse(typeof(SortDirection), ViewState["SortByDirection"].ToString());
}
set { ViewState["SortByDirection"] = value; }
}
Et utilisez-le ensuite dans votre fonction de tri comme ceci:
// Created Date
if (sortBy == "CreatedDate")
{
if (SortByDirection == SortDirection.Ascending)
{
data = data.OrderBy(x => x.CreatedDate).ToList();
SortByDirection = SortDirection.Descending;
}
else {
data = data.OrderByDescending(x => x.CreatedDate).ToList();
SortByDirection = SortDirection.Ascending;
}
}