jQuery ASP.NET: criando uma tela modal para edição de Grid

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace JQUERY_WEB.Util
{
    /// <summary>
    /// Classe auxilia para definir a estrutura de retorno dos dados para o jqGrid
    /// </summary>
    public class GridResult
    {
        /// <summary>
        /// Página atual do grid
        /// </summary>
        public string page { get; set; }
 
        /// <summary>
        /// Total de páginas
        /// </summary>
        public int total { get; set; }
 
        /// <summary>
        /// Quantidade de linhas por página
        /// </summary>
        public string records { get; set; }
 
        /// <summary>
        /// Linhas de dados do grid
        /// </summary>
        public List<GridRow> rows { get; set; }
 
    }
}

  
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace JQUERY_WEB.Util
{
    /// <summary>
    /// Classe auxiliar para definir a estrutura da linha do jqGrid
    /// </summary>
    public class GridRow
    {
        /// <summary>
        /// Id da linha
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// Dados das células da linha
        /// </summary>
        public string[] cell { get; set; }
    }
} 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace JQUERY_WEB.Util
{   
    /// <summary>
    /// Classe auxiliar para configurar a paginação do jqGrid
    /// </summary>
    public class PagingArguments
    {
        /// <summary>
        /// Número da página
        /// </summary>
        public int page { get; set; }
        /// <summary>
        /// Total de linhas por página
        /// </summary>
        public int limit { get; set; }
        /// <summary>
        /// Página inicial
        /// </summary>
        public int start { get; set; }
        /// <summary>
        /// Total de páginas
        /// </summary>
        public int totalPages { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Script.Serialization;
using System.Runtime.Serialization;
using System.Linq.Expressions;
using System.IO;
using System.Reflection;
using System.Text;

namespace JQUERY_WEB.Util
{
  public static class JQGridExtensions
  {
      /// <summary>
      /// Configura o retorno para o grid
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="response"></param>
      /// <param name="page"></param>
      /// <param name="limit"></param>
      /// <param name="sortIndex"></param>
      /// <param name="sortOrder"></param>
      /// <param name="idColumn"></param>
      /// <param name="properties"></param>
      /// <returns></returns>
      public static GridResult ToJQGridResult<T>(this List<T> 
      response, int page, int limit, string sortIndex, string sortOrder, 
      string idColumn, string[] properties)
      {
          
          PagingArguments arguments = 
          GetPagingVariables(response.Count(), page, limit);

          
          StringBuilder sortName = new StringBuilder();
          sortName.Append(sortIndex);
          sortName.Append(" ");
          sortName.Append(sortOrder.ToUpper());
          var sortedResult = response.
          AsQueryable<T>().SortBy<T>(sortName.ToString())
              .Skip(arguments.start)
              .Take(arguments.limit);

          
          GridResult results = new GridResult();
          results.page = arguments.page.ToString();
          results.records = response.Count().ToString();
          results.total = arguments.totalPages;
          results.rows = sortedResult.ToGridRowList(idColumn, properties);

          return results;
      }

      /// <summary>
      /// Método responsável pela paginação e ordenação do grid
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="source"></param>
      /// <param name="propertyName"></param>
      /// <returns></returns>
      public static IQueryable<T> SortBy<T>
      (this IQueryable<T> source, string propertyName)
      {
          if (source == null)
          {
              throw new ArgumentNullException("source");
          }

      
          int descIndex = propertyName.IndexOf(" DESC");
          int ascIndex = propertyName.IndexOf(" ASC");

          if (descIndex >= 0)
          {
              propertyName = propertyName.Substring(0, 
              descIndex).Trim();
          }

          if (ascIndex >= 0)
          {
              propertyName = propertyName.Substring(0, 
              ascIndex).Trim();
          }

          if (String.IsNullOrEmpty(propertyName))
          {
              return source;
          }

          ParameterExpression parameter = 
          Expression.Parameter(source.ElementType, String.Empty);

          MemberExpression property = 
          Expression.Property(parameter, propertyName);

          LambdaExpression lambda = 
          Expression.Lambda(property, parameter);

          string methodName = 
          (descIndex < 0) ? "OrderBy" : "OrderByDescending";

          Expression methodCallExpression = 
          Expression.Call(typeof(Queryable), methodName,
                new Type[] { source.ElementType, property.Type },
                source.Expression, Expression.Quote(lambda));

          return source.Provider.CreateQuery<T>(methodCallExpression);
      }

      /// <summary>
      /// Retorna uma lista de GridRow's de acordo com as propriedades 
      selecionadas.
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="source"></param>
      /// <param name="id"></param>
      /// <param name="properties"></param>
      /// <returns></returns>
      public static List<GridRow> ToGridRowList<T>
      (this IQueryable<T> source, string id, string[] properties)
      {
          List<GridRow> result = new List<GridRow>();

          if (source == null)
          {
              throw new ArgumentNullException("source");
          }

          if (string.IsNullOrEmpty(id))
          {
              throw new ArgumentNullException("id");
          }

          if (properties == null || properties.Length == 0)
          {
              throw new ArgumentNullException("properties");
          }

          foreach (var item in source)
          {
              GridRow row = new GridRow();
              Type type = item.GetType();

              
              PropertyInfo info = type.GetProperty(id);
              row.id = info.GetValue(item, null).ToString();
              row.cell = new string[properties.Length];

              for (int i = 0; i < properties.Length; i++)
              {
                  info = type.GetProperty(properties[i]);
                  if (info.GetValue(item, null) != null)
                      row.cell[i] = info.GetValue(item, null)
                      .ToString();
              }

              result.Add(row);
          }

          return result;
      }

      /// <summary>
      /// Retorna a paginação do grid
      /// </summary>
      /// <param name="countItems"></param>
      /// <param name="page"></param>
      /// <param name="limit"></param>
      /// <returns></returns>
      private static PagingArguments GetPagingVariables(int 
      countItems, int page, int limit)
      {
          PagingArguments arguments = new PagingArguments();

          //Set initial Values
          arguments.page = page;
          arguments.limit = limit;

          //Prepare paging variables            
          float numberOfPages = (float)countItems / (float)limit;
          if (countItems > 0)
          {
              arguments.totalPages = (int)Math.Ceiling(numberOfPages);
          }

          //At least one page
          if (arguments.totalPages == 0)
          {
              arguments.totalPages = 1;
          }

          //Set actual page
          if (arguments.page > arguments.totalPages)
          {
              arguments.page = arguments.totalPages;
          }

          if (arguments.limit < 0)
          {
              arguments.limit = 0;
          }

          //Get paging variables
          arguments.start = arguments.limit * arguments.page - arguments.limit;
          if (arguments.start <= 0)
          {
              arguments.start = 0;
          }

          return arguments;
      }
  }
}

using System.Collections.Generic;
using System.Web.Services;
using System.Web.Script.Services;
using System;
using System.Linq;
using JQUERY_WEB.Dados;
using JQUERY_WEB.Util;

namespace JQUERY_WEB.Services
{
  /// <summary>
  /// Summary description for WSjQuery
  /// </summary>
  [WebService(Namespace = "http://tempuri.org/")]
  [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
  [System.ComponentModel.ToolboxItem(false)]
  [System.Web.Script.Services.ScriptService]
  public class WSjQuery : System.Web.Services.WebService
  {
      [WebMethod, ScriptMethod(ResponseFormat = ResponseFormat.Json)]
      public GridResult GetListAll(int page = 50, int rows = 25, 
      string sidx = "FUNCIONARIO_ID", string sord = "desc", bool _search = true)
      {
          try
          {
              TutoriaisEntities t = new TutoriaisEntities();

              List<FUNCIONARIOS> func = t.FUNCIONARIOS.ToList();

              string[] properties = { "FUNCIONARIO_ID", 
              "FUNCIONARIO_NOME", "FUNCIONARIO_SALARIO" };
              GridResult jsonResults = ((List<FUNCIONARIOS>)func)
              .ToJQGridResult<FUNCIONARIOS>(page, 
              (rows == -1 ? func.Count : rows), sidx, sord, 
              "FUNCIONARIO_ID", properties);

              return jsonResults;
          }
          catch
          {
              //Implemente um tratamento de Erro.
              throw;
          }
      }
  }
}

public partial class WebModal : System.Web.UI.Page
{
    private int ID;

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ID = Convert.ToInt32(Request.QueryString.Get("id"));

            TutoriaisEntities entity = new TutoriaisEntities();

            FUNCIONARIOS func = entity.FUNCIONARIOS.Where(f => f.FUNCAO_ID == ID).FirstOrDefault();

            txtId.Text = func.FUNCIONARIO_ID.ToString();
            txtNome.Text = func.FUNCIONARIO_NOME;
            txtSalario.Text = func.FUNCIONARIO_SALARIO.ToString();
        }
    }
}