В нашем проекте мы не заказываем участникам согласно доступу, но использованием. И этим я имею в виду, мы заказываем участникам, поскольку они используются. Если общедоступный участник использует члена парламента, не занимающего официального поста в том же классе, тот член парламента, не занимающий официального поста обычно располагается перед общедоступным участником где-нибудь, как в следующем (упрощенном) примере:
class Foo
{
private:
int bar;
public:
int GetBar() const
{
return bar;
}
};
Здесь, участник панель помещается перед участником GetBar () , потому что первый используется последним. Это может привести к разделам множественного доступа, как в следующем примере:
class Foo
{
public:
typedef int bar_type;
private:
bar_type bar;
public:
bar_type GetBar() const
{
return bar;
}
};
участник bar_type используется панель участник, посмотрите?
, Почему это? Я не знаю, казалось более естественным, что при обнаружении с участником где-нибудь в реализации и Вам нужно больше деталей о том (и IntelliSense завинчен снова), что можно найти его где-нибудь выше от того, где Вы работаете.
Возможно, да. Вы должны проанализировать строку и, например, скомпилировать делегат, используя деревья выражений.
Вот пример создания (x, y, z) => x + y * z
с использованием деревьев выражений:
ParameterExpression parameterX = Expression.Parameter(typeof(int), "x");
ParameterExpression parameterY = Expression.Parameter(typeof(int), "y");
ParameterExpression parameterZ = Expression.Parameter(typeof(int), "z");
Expression multiplyYZ = Expression.Multiply(parameterY, parameterZ);
Expression addXMultiplyYZ = Expression.Add(parameterX, multiplyYZ);
Func<int,int,int,int> f = Expression.Lambda<Func<int, int, int, int>>
(
addXMultiplyYZ,
parameterX,
parameterY,
parameterZ
).Compile();
Console.WriteLine(f(24, 6, 3)); // prints 42 to the console
C # не имеет подобных функций (в других языках, например в JavaScript, есть функции eval
для обработки подобных вещей). Вам нужно будет проанализировать строку и создать метод самостоятельно либо с деревьями выражений, либо с использованием IL.
Это возможно с помощью грамматики (например, ANTLR) и интерпретатора, который создает деревья выражений. Это нелегкая задача, однако вы можете добиться успеха, если ограничите объем того, что вы принимаете в качестве входных данных. Вот несколько ссылок:
Вот как может выглядеть некоторый код для преобразования ITree ANTLR в дерево выражений. Он не полный, но показывает, с чем вы сталкиваетесь.
private Dictionary<string, ParameterExpression> variables
= new Dictionary<string, ParameterExpression>();
public Expression Visit(ITree tree)
{
switch(tree.Type)
{
case MyParser.NUMBER_LITERAL:
{
float value;
var literal = tree.GetChild(0).Text;
if (!Single.TryParse(literal, out value))
throw new MyParserException("Invalid number literal");
return Expression.Constant(value);
}
case MyParser.IDENTIFIER:
{
var ident = tree.GetChild(0).Text;
if (!this.variables.ContainsKey(ident))
{
this.variables.Add(ident,
Expression.Parameter(typeof(float), ident));
}
return this.variables[ident];
}
case MyParser.ADD_EXPR:
return Expression.Add(Visit(tree.GetChild(0)), Visit(tree.GetChild(1)));
// ... more here
}
}
В инфраструктуре .Net есть функции для этого.
Это непросто. Вам нужно добавить код вокруг оператора, чтобы превратить его в полную сборку, включая класс и метод, которые вы можете вызвать.
После этого вы передаете строку в
CSharpCodeProvider.CompileAssemblyFromSource(options, yourcode);
Просто для развлечения с использованием CodeDom (в строке допускается любой допустимый код C #, если он присутствует в mscorlib (вообще нет проверки на наличие ошибок):
static class Program
{
static string code = @"
public static class __CompiledExpr__
{{
public static {0} Run({1})
{{
return {2};
}}
}}
";
static MethodInfo ToMethod(string expr, Type[] argTypes, string[] argNames, Type resultType)
{
StringBuilder argString = new StringBuilder();
for (int i = 0; i < argTypes.Length; i++)
{
if (i != 0) argString.Append(", ");
argString.AppendFormat("{0} {1}", argTypes[i].FullName, argNames[i]);
}
string finalCode = string.Format(code, resultType != null ? resultType.FullName : "void",
argString, expr);
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add(Path.GetFileName(Assembly.GetExecutingAssembly().Location));
parameters.GenerateInMemory = true;
var c = new CSharpCodeProvider();
CompilerResults results = c.CompileAssemblyFromSource(parameters, finalCode);
var asm = results.CompiledAssembly;
var compiledType = asm.GetType("__CompiledExpr__");
return compiledType.GetMethod("Run");
}
static Action ToAction(this string expr)
{
var method = ToMethod(expr, new Type[0], new string[0], null);
return () => method.Invoke(null, new object[0]);
}
static Func<TResult> ToFunc<TResult>(this string expr)
{
var method = ToMethod(expr, new Type[0], new string[0], typeof(TResult));
return () => (TResult)method.Invoke(null, new object[0]);
}
static Func<T, TResult> ToFunc<T, TResult>(this string expr, string arg1Name)
{
var method = ToMethod(expr, new Type[] { typeof(T) }, new string[] { arg1Name }, typeof(TResult));
return (T arg1) => (TResult)method.Invoke(null, new object[] { arg1 });
}
static Func<T1, T2, TResult> ToFunc<T1, T2, TResult>(this string expr, string arg1Name, string arg2Name)
{
var method = ToMethod(expr, new Type[] { typeof(T1), typeof(T2) },
new string[] { arg1Name, arg2Name }, typeof(TResult));
return (T1 arg1, T2 arg2) => (TResult)method.Invoke(null, new object[] { arg1, arg2 });
}
static Func<T1, T2, T3, TResult> ToFunc<T1, T2, T3, TResult>(this string expr, string arg1Name, string arg2Name, string arg3Name)
{
var method = ToMethod(expr, new Type[] { typeof(T1), typeof(T2), typeof(T3) },
new string[] { arg1Name, arg2Name, arg3Name }, typeof(TResult));
return (T1 arg1, T2 arg2, T3 arg3) => (TResult)method.Invoke(null, new object[] { arg1, arg2, arg3 });
}
static void Main(string[] args)
{
var f = "x + y * z".ToFunc<int, int, long, long>("x", "y", "z");
var x = f(3, 6, 8);
}
}