DynamicExpresso表达式求值

最新推荐文章于 2024-06-05 15:46:29 发布
最新推荐文章于 2024-06-05 15:46:29 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： C# .NET 文章标签： C# 表达式求值 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhchfsky/article/details/104010888
版权
.NET 同时被 2 个专栏收录
19 篇文章 1 订阅
订阅专栏
C#
18 篇文章 0 订阅
订阅专栏

DynamicExpresso 2.3.1 最低要求.net 4.6.1

github地址：https://github.com/davideicardi/DynamicExpresso

常用方法

/// <summary>
/// 忽略大小写判断相等
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static bool EqualsIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return true;

    if (str1 == null || str2 == null)
    {
        return false;
    }

    return string.Equals(str1.ToString(), str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

/// <summary>
/// str1 以 str2开头
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static bool StartsWithIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return true;

    if (str1 == null || str2 == null)
    {
        return false;
    }

    return str1.ToString().StartsWith(str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

/// <summary>
/// str1 以 str2 结尾
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static bool EndsWithIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return true;

    if (str1 == null || str2 == null)
    {
        return false;
    }

    return str1.ToString().EndsWith(str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

/// <summary>
/// 忽略大小写 比较
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static int CompareIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return 0;

    if (str1 == null || str2 == null)
    {
        return 0;
    }

    return string.Compare(str1.ToString(), str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

/// <summary>
/// 索引位置
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static int IndexOfIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return -1;

    if (str1 == null || str2 == null)
    {
        return -1;
    }

    return str1.ToString().IndexOf(str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

/// <summary>
/// 匹配最后一个索引位置
/// </summary>
/// <param name="str1"></param>
/// <param name="str2"></param>
/// <returns></returns>
public static int LastIndexOfIgnorecase(object str1, object str2)
{
    if (str1 == null && str2 == null)
        return -1;

    if (str1 == null || str2 == null)
    {
        return -1;
    }

    return str1.ToString().LastIndexOf(str2.ToString(), StringComparison.OrdinalIgnoreCase);
}

DynamicExpressoHelper类

public static class DynamicExpressoHelper
{
	static readonly Interpreter _interpreter = new Interpreter();

	static readonly Type eType = typeof(Enumerable);

	#region 列表方法
	static readonly MethodInfo anyMethod = null;
	static readonly MethodInfo whereAnyMethod = null;
	static readonly MethodInfo whereMethod = null;
	static readonly MethodInfo countMethod = null;
	static readonly MethodInfo whereCountMethod = null;
	static readonly MethodInfo firstMethod = null;
	static readonly MethodInfo whereFirstMethod = null;
	static readonly MethodInfo firstOrDefaultMethod = null;
	static readonly MethodInfo whereFirstOrDefaultMethod = null;
	static readonly MethodInfo lastMethod = null;
	static readonly MethodInfo whereLastMethod = null;
	static readonly MethodInfo lastOrDefaultMethod = null;
	static readonly MethodInfo whereLastOrDefaultMethod = null;
	#endregion

	static readonly Type whereType = typeof(Func<,>);

	static readonly MethodInfo parseDelegateMethod = null;

	static readonly Type enumType = typeof(IEnumerable<>);

	static readonly Type nullableType = typeof(Nullable<>);

	static DynamicExpressoHelper()
	{
		#region 支持的方法
		MethodInfo[] methods = eType.GetMethods();
		foreach(MethodInfo method in methods)
		{
			if (method.Name == "Any")
			{
				if (Enumerable.Count(method.GetParameters()) == 1)
				{
					anyMethod = method;
				}
				else
				{
					whereAnyMethod = method;
				}
			}
			if (method.Name == "Count")
			{
				if (Enumerable.Count(method.GetParameters()) == 1)
				{
					countMethod = method;
				}
				else
				{
					whereCountMethod = method;
				}
			}
			if (method.Name == "Where")
			{
				if(method.GetParameters()[1].ParameterType.GetGenericArguments().Length == 2)
				{
					whereMethod = method;
				}
			}
		}
		#endregion
		parseDelegateMethod = _interpreter.GetType().GetMethod("ParseAsDelegate", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod); ;
	}

	#region 字符串操作
	/// <summary>
	/// 忽略大小写判断相等
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static bool EqualsIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return true;

		if (str1 == null || str2 == null)
		{
			return false;
		}

		return string.Equals(str1.ToString(), str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// str1 以 str2开头
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static bool StartsWithIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return true;

		if (str1 == null || str2 == null)
		{
			return false;
		}

		return str1.ToString().StartsWith(str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// str1 以 str2 结尾
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static bool EndsWithIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return true;

		if (str1 == null || str2 == null)
		{
			return false;
		}

		return str1.ToString().EndsWith(str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// 忽略大小写 比较
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static int CompareIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return 0;

		if (str1 == null || str2 == null)
		{
			return 0;
		}

		return string.Compare(str1.ToString(), str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// 索引位置
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static int IndexOfIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return -1;

		if (str1 == null || str2 == null)
		{
			return -1;
		}

		return str1.ToString().IndexOf(str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// 匹配最后一个索引位置
	/// </summary>
	/// <param name="str1"></param>
	/// <param name="str2"></param>
	/// <returns></returns>
	public static int LastIndexOfIgnorecase(this ExpandoObject obj, object str1, object str2)
	{
		if (str1 == null && str2 == null)
			return -1;

		if (str1 == null || str2 == null)
		{
			return -1;
		}

		return str1.ToString().LastIndexOf(str2.ToString(), StringComparison.OrdinalIgnoreCase);
	}
	#endregion

	#region 列表

	/// <summary>
	/// 统计
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object Any(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return anyMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereAnyMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 过滤
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object Where(this object list, string expression)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null || string.IsNullOrEmpty(expression))
		{
			return list;
		}

		Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
		MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
		object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
		return whereMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
	}

	/// <summary>
	/// 统计
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object Count(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return countMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereCountMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 统计
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object First(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return firstMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereFirstMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 统计
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object FirstOrDefault(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return firstOrDefaultMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereFirstOrDefaultMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 最后一个
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object Last(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return lastMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereLastMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 最后一个
	/// </summary>
	/// <param name="list">列表</param>
	/// <param name="expression">表达式</param>
	/// <returns></returns>
	public static object LastOrDefault(this object list, string expression = null)
	{
		Type type = list.GetType();
		Tuple<Type, Type> genericType = GetEnumerableGenericType(type);
		if (genericType == null)
		{
			return list;
		}

		if (string.IsNullOrEmpty(expression))
		{
			return lastOrDefaultMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list });
		}
		else
		{
			Type funcType = whereType.MakeGenericType(genericType.Item1, typeof(bool));
			MethodInfo parseMethod = parseDelegateMethod.MakeGenericMethod(funcType);
			object predicate = parseMethod.Invoke(_interpreter, new object[] { expression, new string[] { "o" } });
			return whereLastOrDefaultMethod.MakeGenericMethod(genericType.Item1).Invoke(null, new object[] { list, predicate });
		}
	}

	/// <summary>
	/// 获取列表泛型类型
	/// </summary>
	/// <param name="type">列表类型</param>
	/// <returns></returns>
	private static Tuple<Type,Type> GetEnumerableGenericType(Type type)
	{
		if (type.IsGenericType)
		{
			if (type.GetGenericTypeDefinition() == nullableType)
			{
				return null;
			}

			Type genericType = type.GetGenericArguments()[0];
			Type listType = enumType.MakeGenericType(genericType);
			if (listType.IsAssignableFrom(type))
			{
				return Tuple.Create(genericType, listType);
			}
		}
		return null;
	}
	#endregion

	#region 字典
	/// <summary>
	/// 求取字典值
	/// </summary>
	/// <param name="key">键</param>
	/// <returns></returns>
	public static object Value(this ExpandoObject obj, string key)
	{
		IDictionary<string, object> dic = obj as IDictionary<string, object>;
		return dic.ContainsKey(key) ? dic[key] : null;
	}

	/// <summary>
	/// 是否包含键
	/// </summary>
	/// <param name="key">键</param>
	/// <returns></returns>
	public static bool Exists(this ExpandoObject obj, string key)
	{
		IDictionary<string, object> dic = obj as IDictionary<string, object>;
		return dic.ContainsKey(key);
	}
	#endregion
}

扩展string

/// <summary>
/// 解析表达式
/// </summary>
/// <param name="str">字符串</param>
/// <param name="obj">参数</param>
/// <param name="paramName">参数名</param>
/// <returns></returns>
public static T Eval<T>(this string str, object obj = null, string paramName = "obj")
{
	Interpreter expr = new Interpreter(InterpreterOptions.Default)
		.EnableReflection()
		.Reference(typeof(ExpandoObject))
		.Reference(typeof(DynamicExpressoHelper))
		.SetFunction("equalsIgnore", (Func<object, object, bool>)EqualsIgnorecase)
		.SetFunction("startsIgnore", (Func<object, object, bool>)StartsWithIgnorecase)
		.SetFunction("endsIgnore", (Func<object, object, bool>)EndsWithIgnorecase)
		.SetFunction("compareIgnore", (Func<object, object, int>)CompareIgnorecase)
		.SetFunction("indexOfIgnore", (Func<object, object, int>)IndexOfIgnorecase)
		.SetFunction("lastIndexOfIgnore", (Func<object, object, int>)LastIndexOfIgnorecase);
	if (obj != null)
	{
		paramName = paramName ?? "obj";
		expr.SetVariable(paramName, obj);
	}
	return expr.Eval<T>(str);
}

测试：

using DynamicExpresso;
using System;
using System.Collections.Generic;
using System.Dynamic;

namespace Test
{
    class Program
    {
        static void Main()
        {
            int result = "3+2".Eval<int>();
            Console.WriteLine(result);

            dynamic obj = new ExpandoObject();
            obj.Name = ".net";
            obj.Id = 10;

            IDictionary<string, object> dic = obj as IDictionary<string, object>;
            dic.Add("Address", "北京市东城区");
            /*
            var interpreter = new Interpreter()
                .SetVariable("obj", (object)obj);
            Console.WriteLine(obj.Id == interpreter.Eval<int>("obj.Id"));
            */

            //True
            bool flag = "((int)obj.Id) > 2 && equalsIgnore(obj.Name,\".Net\") && startsIgnore(obj.Name,\".\")"
                .Eval<bool>("obj", (object)obj);
            Console.WriteLine(flag);

            //True
            flag = "obj.Address.Contains(\"北京\")".Eval<bool>("obj", (object)obj);
            Console.WriteLine(flag);

            List<Detail> details = new List<Detail>();
            Detail detail = new Detail();
            detail.id = 12;
            detail.name = "您好";
            details.Add(detail);
            dynamic obj = new ExpandoObject();
            obj.details = details;
            int count = "obj.details.Where(\"o.id>10\").Count()".Eval<int>((object)obj);
            Console.WriteLine(count);
            Console.ReadLine();
        }
    }

    class Detail
    {
        public int id { get; set; }
        public string name { get; set; }
    }
}

结果（4.7.1，4.6.1一样）

闪耀星星
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DynamicExpresso:C# 表达式解释器
07-24
动态快车 可用平台：.NET Core 2.0、.NET 4.5、.NET 4.6.1 Dynamic Expresso 是用 .NET Standard 2.0 编写的简单 C# 语句的解释器。 Dynamic Expresso 嵌入了自己的解析逻辑，通过将其转换为 .NET lambda 表达式或委托来真正解释 C# 语句。 使用 Dynamic Expresso 开发人员可以创建可编写脚本的应用程序、无需编译即可执行 .NET 代码或创建动态 linq 语句。 语句是使用 C# 语言规范的子集编写的。 可以在表达式中注入和使用全局变量或参数。 它不会生成程序集，但会动态创建表达式树。 例如，您可以计算数学表达式： var interpreter = new Interpreter (); var result = interpreter . Eval ( " 8 / 2
表达式求值源码
05-23
表达式求值程序，希望可以给在学习C语言的童鞋们提供一些帮助。
Dynamic Expresso--一个精简的C#表达式执行框架
寒冰屋的专栏
05-04 741
Dynamic Expresso是一个用.NET Standard 2.0编写的简单c#语句的解释器。 Dynamic Expresso嵌入了自己的解析逻辑，通过将其转换为.NET lambda表达式或委托来解释c#语句。
DynamicExpresso：强大的动态执行C#表达式解析器
最新发布
dotNET跨平台
06-05 47
推荐一个强大动态表达式解析器，方便我们在项目中，动态执行C#脚本。01项目简介DynamicExpresso内置了解析逻辑，它能够将.NET的lambda表达式或委托转化为C#语句，并在内存中的动态执行。它不生成任何汇编，而是构建了一个表达式树，在运行时执行。支持如加减乘除、比较、逻辑操作等基本运算符以及C#中的类型测试和转换。可以声明和使用变量，包括自定义类型的实例；也可以设置参数，便于多次调用...
Dynamic Expresso的应用
kalvin_y_liu的博客
08-20 903
Dynamic Expresso 是用 .NET Standard 2.0 编写的简单 C# 语句的解释器。Dynamic Expresso 嵌入了自己的解析逻辑，通过将 C# 语句转换为 .NET lambda 表达式或委托来真正解释 C# 语句。使用 Dynamic Expresso 开发人员可以创建可编写脚本的应用程序，无需编译即可执行 .NET 代码或创建动态 linq 语句。语句是使用 C# 语言规范的子集编写的。全局变量或参数可以在表达式中注入和使用。
CShell + DynamicExpresso =》 灵活又强大的表达式计算器
plplwkk的博客
01-11 1144
CShell是一个轻量级可扩展的C#语法REPL工具。 Dynamic Expresso是一个用于.NET标准2.0中编写的简单C#语句的解释器。Dynamic Expresso嵌入了自己的解析逻辑，通过将C#语句转换为.NET lambda表达式或委托来解释它。使用dynamicexpresso，开发人员可以创建可编写脚本的应用程序、执行.NET代码而无需编译或创建动态linq语句。表达式语句是使用C#语言规范的子集编写的。全局变量或参数可以在表达式中注入和使用。它不会生成程序集，但会动态创建表达式树。
动态表达式(Dynamic Expresso): 快速灵活的C代码解释器
gitblog_00025的博客
05-09 353
动态表达式(Dynamic Expresso): 快速灵活的C#代码解释器 项目地址:https://gitcode.com/dynamicexpresso/DynamicExpresso 动态表达式是一个强大的.NET库，它允许你在运行时解析并执行简单的C#语句，无需编译。这个开源项目以其高效和易用性为开发者提供了构建可脚本化的应用程序、执行无编译的.NET代码以及创建动态LINQ查询的能力。 ...
8.表达式求值_python/表达式求值_
09-29
在Python编程语言中，表达式求值是一项基本且重要的任务，它涉及到将字符串形式的数学或逻辑表达式转换为实际的计算结果。本教程将深入探讨如何使用Python来实现表达式求值，特别是通过五行代码的简洁实现，以及相关...
表达式求值代码
08-30
在编程领域，表达式求值是计算数学或逻辑表达式以获取结果的过程。在这个场景中，我们关注的是如何使用栈数据结构来实现这个功能。栈是一种后进先出（LIFO）的数据结构，非常适合处理括号匹配和运算符优先级问题，这...
表达式求值
11-01
在IT领域，表达式求值是一项基础且重要的任务，它涉及到计算机如何解析并计算数学、逻辑或编程语言中的表达式。这个"表达式求值"的JAR包提供了一个便捷的方式来处理这种计算，使得开发者无需从头实现复杂的解析和...
C# 表达式解析器源代码(修正)
01-23
一个C#实现的简单表达式解析器，支持算符优先级、括号以及函数。 修正前一个上传版本存在的问题：算符优先级的错误。
biaodashi.zip_表达式求值
09-19
在编程领域，表达式求值（Expression Evaluation）是一项核心任务，特别是在解释型语言或编译器设计中。这里我们以“biaodashi.zip_表达式求值”为例，探讨使用C++实现表达式求值的相关知识点。 首先，理解表达式求...
如何校验内存数据的一致性，DynamicExpresso 算是帮上大忙了
dotNET跨平台
08-20 251
一：背景1. 讲故事记的在上一家公司做全内存项目的时候，因为一些关键表会在程序 startup 的时候全量灌入到内存中，但随着时间的推移，内存和数据库的同步偶尔会出现数据差异的情况，伴随...
一个精简的C#表达式执行框架Dynamic Expresso
dotNET跨平台
06-04 686
一、简介Dynamic Expresso是一个用.NET Standard 2.0编写的简单c#语句的解释器。Dynamic Expresso嵌入了自己的解析逻辑，通过将其转换为.NET lambda表达式或委托来解释c#语句。使用Dynamic Expresso开发人员可以创建可编写脚本的应用程序，无需编译即可执行.NET代码，或者创建动态linq语句。语句是使用c#语...
探索DynamicExpresso：强大的动态表达式编译器
gitblog_00002的博客
03-24 472
探索DynamicExpresso：强大的动态表达式编译器 项目地址:https://gitcode.com/davideicardi/DynamicExpresso DynamicExpresso是一个小巧而强大的.NET库，专为解析、编译和执行动态表达式设计。该项目由Davide Icardi开发，它提供了在运行时构建和执行代码的能力，这对于那些需要灵活处理业务逻辑或数据过滤的应用来说，是极其...
数据结构栈表达式求值
09-29
数据结构中栈的应用之一就是表达式求值。表达式求值是程序设计语言编译中一个最基本的问题。在表达式求值中，栈被用作一个典型的工具。 在表达式求值过程中，中缀表达式需要考虑运算符的优先级以及处理括号。而后缀...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闪耀星星

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值