Breeze 如何使用接受分页参数的存储过程_Breeze

Breeze 如何使用接受分页参数的存储过程

breeze

Breeze 如何使用接受分页参数的存储过程,breeze,Breeze,使用breeze时如何使用存储过程的任何链接示例，主要关注如何提取分页参数和设置inlinecount值，因为存储过程将返回该值并获取分页参数即 SP_输入_Para2等等类似的更新 function Update(string SP_Input_Param1, string SP_Input_Param2 etc) 然后介绍如何配置Breeze，告诉它应该在服务器上使用以下函数获取和更新、删除、插入等或者更好的方法就是这样对于Get，请使用请求和响应作为自定义结构 i.e

使用breeze时如何使用存储过程的任何链接示例，主要关注如何提取分页参数和设置inlinecount值，因为存储过程将返回该值并获取分页参数

即

SP_输入_Para2等等

类似的更新

    function Update(string SP_Input_Param1, string SP_Input_Param2 etc)

然后介绍如何配置Breeze，告诉它应该在服务器上使用以下函数获取和更新、删除、插入等

或者更好的方法就是这样对于Get，请使用请求和响应作为自定义结构

i.e
    public class MyResponse
{
    public IEnumerable<Object> Results { get; set; }
    public string Message { get; set; }


}
public class MyRequest
{
    public PagingInfo pageInfo { get; set; }
    public ParameterInfo Parameters { get; set; }
}


public class PagingInfo
{
    public int PageIndex { get; set; }
    public int PageSize { get; set; }
}

public class ParameterInfo
{
    public string Parameter1 { get; set; }
    public string Parameter2 { get; set; }
    public string Parameter3 { get; set; }
}

then use

public MyResponse GetData(MyResponse request)
        {
            var resp = new MyResponse();
            var lst = new List<object>();
            // do oyur work
            resp.Results= lst;

            return lst;
        }

即
公共类MyResponse
{
公共IEnumerable结果{get；set；}
公共字符串消息{get；set；}
}
公共类MyRequest
{
公共分页信息pageInfo{get；set；}
公共参数信息参数{get；set；}
}
公共类分页信息
{
公共int页索引{get；set；}
公共int PageSize{get；set；}
}
公共类参数信息
{
公共字符串参数1{get；set；}
公共字符串参数2{get；set；}
公共字符串参数3{get；set；}
}
然后使用
公共MyResponse GetData（MyResponse请求）
{
var resp=新的MyResponse（）；
var lst=新列表（）；
//做你的工作吗
相应结果=lst；
返回lst；
}

现在，您可能需要在客户端上提供一个函数来映射集合，这是一个好问题，但是我们还没有将存储过程与breeze一起使用的示例，尽管它是完全可行的。请把这个加进去，投赞成票。我们认真对待您的反馈

这是一个很好的问题，但是我们还没有将存储过程与breeze一起使用的例子，尽管它是完全可行的。请把这个加进去，投赞成票。我们认真对待您的反馈

要从breeze请求中查询信息，请尝试将此作为GET方法。这假设GetMyEntityType返回数据上下文中的实体

[HttpGet]
[EnableBreezeQuery(MaxExpansionDepth = 0)]
public QueryResult GetMyEntityType(ODataQueryOptions<MyEntityType> options)
{
... your server method
}

您是否知道可以执行一个存储过程来返回多个结果集，并使用MARS使用这些结果？我当前运行的存储过程在一次SQL往返中返回23个IQueryable

祝你好运

（编辑）

如果在存储过程中手动应用$skip和$top，Breeze将再次尝试对结果集应用它们。在本例中，我只是将skip和top作为参数发送，而不是使用$skip和$top。顺便说一句，这个bug花了7个小时才找到

此链接：显示如何将IQueryable对象转换为T-SQL。使用options.filter.ApplyTo将breeze筛选器应用于MyEntityType的空白IQueryable，然后使用上面链接中的代码将breeze请求呈现到TSQL中

// Determine the where clause 
var whereClause = options.Filter == null ? "" : ToTraceString<MyEntityType>(
    options.Filter.ApplyTo(
        (from x in DB.Context.MyEntityTypes select x),
        new ODataQuerySettings()) as IQueryable<MyEntityType>)
    .Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).Where(x => x.Trim().StartsWith("WHERE")).FirstOrDefault().Trim();

/* Steve Fenton, https://www.stevefenton.co.uk/2015/07/getting-the-sql-query-from-an-entity-framework-iqueryable/
 * July 24, 2015
 * */
private static string ToTraceString<T>(IQueryable<T> query)
{
    var internalQueryField = query.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_internalQuery")).FirstOrDefault();
    var internalQuery = internalQueryField.GetValue(query);
    var objectQueryField = internalQuery.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_objectQuery")).FirstOrDefault();
    var objectQuery = objectQueryField.GetValue(internalQuery) as System.Data.Entity.Core.Objects.ObjectQuery<T>;
    return ToTraceStringWithParameters<T>(objectQuery);
}
private static string ToTraceStringWithParameters<T>(System.Data.Entity.Core.Objects.ObjectQuery<T> query)
{
    System.Text.StringBuilder sb = new StringBuilder();
    string traceString = query.ToTraceString() + Environment.NewLine;
    foreach (var parameter in query.Parameters)
        traceString = traceString.Replace("@" + parameter.Name, "'" + parameter.Value.ToString() + "'");
    return traceString;
}
/* */

//确定where子句
var whereClause=options.Filter==null？“”：ToTraceString(
options.Filter.ApplyTo(
（从DB.Context.MyEntityTypes中的x选择x），
新ODataQuerySettings（））作为IQueryable）
.Split（新[]{“\r”，“\n”}，StringSplitOptions.RemoveEmptyEntries）。其中（x=>x.Trim（）.StartsWith（“Where”））.FirstOrDefault（）.Trim（）；
/*史蒂夫·芬顿，https://www.stevefenton.co.uk/2015/07/getting-the-sql-query-from-an-entity-framework-iqueryable/
*2015年7月24日
* */
私有静态字符串ToTraceString（IQueryable查询）
{
var internalQueryField=query.GetType（）.GetFields（System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance）。其中（f=>f.Name.Equals（“_internalQuery”））.FirstOrDefault（）；
var internalQuery=internalQueryField.GetValue（查询）；
var objectQueryField=internalQuery.GetType（）.GetFields（System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance）。其中（f=>f.Name.Equals（“_objectQuery”））.FirstOrDefault（）；
var objectQuery=objectQueryField.GetValue（internalQuery）作为System.Data.Entity.Core.Objects.objectQuery；
返回带有参数的TraceStringWithParameters（objectQuery）；
}
私有静态字符串ToTraceStringWithParameters（System.Data.Entity.Core.Objects.ObjectQuery）
{
System.Text.StringBuilder sb=新的StringBuilder（）；
string traceString=query.ToTraceString（）+Environment.NewLine；
foreach（query.Parameters中的var参数）
traceString=traceString.Replace（“@”+parameter.Name，“'”+parameter.Value.ToString（）+”）；
回程追踪；
}
/* */

要从breeze请求中查询信息，请尝试将此作为GET方法。这假设GetMyEntityType返回数据上下文中的实体

[HttpGet]
[EnableBreezeQuery(MaxExpansionDepth = 0)]
public QueryResult GetMyEntityType(ODataQueryOptions<MyEntityType> options)
{
... your server method
}

您是否知道可以执行一个存储过程来返回多个结果集，并使用MARS使用这些结果？我当前运行的存储过程在一次SQL往返中返回23个IQueryable

祝你好运

（编辑）

// Determine the where clause 
var whereClause = options.Filter == null ? "" : ToTraceString<MyEntityType>(
    options.Filter.ApplyTo(
        (from x in DB.Context.MyEntityTypes select x),
        new ODataQuerySettings()) as IQueryable<MyEntityType>)
    .Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).Where(x => x.Trim().StartsWith("WHERE")).FirstOrDefault().Trim();

/* Steve Fenton, https://www.stevefenton.co.uk/2015/07/getting-the-sql-query-from-an-entity-framework-iqueryable/
 * July 24, 2015
 * */
private static string ToTraceString<T>(IQueryable<T> query)
{
    var internalQueryField = query.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_internalQuery")).FirstOrDefault();
    var internalQuery = internalQueryField.GetValue(query);
    var objectQueryField = internalQuery.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_objectQuery")).FirstOrDefault();
    var objectQuery = objectQueryField.GetValue(internalQuery) as System.Data.Entity.Core.Objects.ObjectQuery<T>;
    return ToTraceStringWithParameters<T>(objectQuery);
}
private static string ToTraceStringWithParameters<T>(System.Data.Entity.Core.Objects.ObjectQuery<T> query)
{
    System.Text.StringBuilder sb = new StringBuilder();
    string traceString = query.ToTraceString() + Environment.NewLine;
    foreach (var parameter in query.Parameters)
        traceString = traceString.Replace("@" + parameter.Name, "'" + parameter.Value.ToString() + "'");
    return traceString;
}
/* */

//确定where子句
var whereClause=options.Filter==null？“”：ToTraceString(
options.Filter.ApplyTo(
（从DB.Context.MyEntityTypes中的x选择x），
新ODataQuerySettings（））作为IQueryable）
.Split（新[]{“\r”，“\n”}，StringSplitOptions.RemoveEmptyEntries）。其中（x=>x.Trim（）.StartsWith（“Where”））.FirstOrDefault（）.Trim（）；
/*史蒂夫·芬顿，https://www.stevefenton.co.uk/2015/07/getting-the-sql-query-from-an-entity-framework-iqueryable/
*2015年7月24日
* */
私有静态字符串ToTraceString（IQueryable查询）
{
var internalQueryField=query.GetType（）.GetFields（System.Refle
        return new QueryResult()
        {
            InlineCount = myInlineCount,
            Results = DB.ObjectContext.ExecuteStoreQuery<MyEntityType>(query).ToList()
        };

    private void ProcessUnaryOperator(UnaryOperatorNode unaryOperator, List<ODataFilter> filterList)
    {
        if (unaryOperator != null)
        {
            if (unaryOperator.Operand != null && unaryOperator.Operand.GetType().FullName == "Microsoft.Data.OData.Query.SemanticAst.BinaryOperatorNode")
            {
                ProcessBinaryOperator(unaryOperator.Operand as BinaryOperatorNode, filterList);
            }
        }
    }

    private void ProcessBinaryOperator(BinaryOperatorNode binaryOperator, List<ODataFilter> filterList)
    {
        if (binaryOperator != null)
        {
            if (binaryOperator.Left != null && binaryOperator.Left.GetType().FullName == "Microsoft.Data.OData.Query.SemanticAst.BinaryOperatorNode")
                ProcessBinaryOperator(binaryOperator.Left as BinaryOperatorNode, filterList);

            if (binaryOperator.Right != null && binaryOperator.Right.GetType().FullName == "Microsoft.Data.OData.Query.SemanticAst.BinaryOperatorNode")
                ProcessBinaryOperator(binaryOperator.Right as BinaryOperatorNode, filterList);

            if (binaryOperator.Left != null && binaryOperator.Left.GetType().FullName == "Microsoft.Data.OData.Query.SingleValueFunctionCallNode")
            {
                var singleValueFunctionCallNode = binaryOperator.Left as SingleValueFunctionCallNode;

                var property = (singleValueFunctionCallNode.Arguments.FirstOrDefault() as SingleValuePropertyAccessNode ?? singleValueFunctionCallNode.Arguments.LastOrDefault() as SingleValuePropertyAccessNode) ;
                var constant = (singleValueFunctionCallNode.Arguments.FirstOrDefault() as ConstantNode ?? singleValueFunctionCallNode.Arguments.LastOrDefault() as ConstantNode);

                var lt = string.Empty;
                switch (singleValueFunctionCallNode.Name)
                {
                    case "startswith":
                        lt = constant.Value.ToString() + "%";
                        break;
                    case "endswith":
                        lt = "%" + constant.Value.ToString();
                        break;
                    case "substringof":
                        lt = "%" + constant.Value.ToString() + "%";
                        break;
                    case "equal":
                        lt = constant.Value.ToString();
                        break;
                }

                if (property != null && property.Property != null && constant != null && constant.Value != null)
                    filterList.Add(new ODataFilter(property.Property.Name, binaryOperator.OperatorKind.ToString(), lt, property, constant));
            }

            if (binaryOperator.Left != null && binaryOperator.Left.GetType().FullName == "Microsoft.Data.OData.Query.SingleValuePropertyAccessNode")
            {
                var property = binaryOperator.Left as SingleValuePropertyAccessNode ?? binaryOperator.Right as SingleValuePropertyAccessNode;
                var constant = binaryOperator.Left as ConstantNode ?? binaryOperator.Right as ConstantNode;
                var lt = constant.Value.ToString();

                if (property != null && property.Property != null && constant != null && constant.Value != null)
                    filterList.Add(new ODataFilter(property.Property.Name, binaryOperator.OperatorKind.ToString(), lt, property, constant));
            }
        }
    }

    public class ODataFilter
    {
        public ODataFilter(string prop, string op, string lt, SingleValuePropertyAccessNode pn, ConstantNode cn)
        {
            this.Property = prop;
            this.Operator = op;
            this.LiteralText = lt;
            this.PropertyNode = pn;
            this.ConstantNode = cn;
        }

        public string Property { get; set; }
        public string Operator { get; set; }
        public string LiteralText { get; set; }
        public SingleValuePropertyAccessNode PropertyNode { get; set; }
        public ConstantNode ConstantNode { get; set; }
    }

        List<ODataFilter> filterList = new List<ODataFilter>();

        // Not Equal (Unary Operators)
        if (options.Filter != null && options.Filter.FilterClause != null && options.Filter.FilterClause.Expression.GetType().Name == "UnaryOperatorNode")
            ProcessUnaryOperator(options.Filter.FilterClause.Expression as UnaryOperatorNode, filterList);

        // Equal (Binary Operators)
        if (options.Filter != null && options.Filter.FilterClause != null && options.Filter.FilterClause.Expression.GetType().Name == "BinaryOperatorNode")
            ProcessBinaryOperator(options.Filter.FilterClause.Expression as BinaryOperatorNode, filterList);

using Microsoft.Data.OData.Query; 
using System.Web.Http.OData.Query; 
using Microsoft.Data.OData.Query.SemanticAst;

// Determine the where clause 
var whereClause = options.Filter == null ? "" : ToTraceString<MyEntityType>(
    options.Filter.ApplyTo(
        (from x in DB.Context.MyEntityTypes select x),
        new ODataQuerySettings()) as IQueryable<MyEntityType>)
    .Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).Where(x => x.Trim().StartsWith("WHERE")).FirstOrDefault().Trim();

/* Steve Fenton, https://www.stevefenton.co.uk/2015/07/getting-the-sql-query-from-an-entity-framework-iqueryable/
 * July 24, 2015
 * */
private static string ToTraceString<T>(IQueryable<T> query)
{
    var internalQueryField = query.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_internalQuery")).FirstOrDefault();
    var internalQuery = internalQueryField.GetValue(query);
    var objectQueryField = internalQuery.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Where(f => f.Name.Equals("_objectQuery")).FirstOrDefault();
    var objectQuery = objectQueryField.GetValue(internalQuery) as System.Data.Entity.Core.Objects.ObjectQuery<T>;
    return ToTraceStringWithParameters<T>(objectQuery);
}
private static string ToTraceStringWithParameters<T>(System.Data.Entity.Core.Objects.ObjectQuery<T> query)
{
    System.Text.StringBuilder sb = new StringBuilder();
    string traceString = query.ToTraceString() + Environment.NewLine;
    foreach (var parameter in query.Parameters)
        traceString = traceString.Replace("@" + parameter.Name, "'" + parameter.Value.ToString() + "'");
    return traceString;
}
/* */