博客园_编程之美

DMSLinq表达式框架实现(六)

2012-05-26T11:20:00Z

这段时间一直在优化DMSLinq,也看到了有些方法存在不合理处.还把框架内的公用类进行了分解,以后可以开源用.优化了一些方法,使其更能支持每个人的习惯写法~

1.改进Join前不能加Where条件的BUG

2.改进查询列时As方法用new匿名实例时出现两个As列名的现象

3.增加WhereClip等动态拼接条件

4.修改Guid.NewID()返回为空的现象

5.增加实体过滤条件,DMSLinqQueryProvider处理器,以Config形式加入Filter,做数据权限时会用到!可用实体的形式过滤,也可以用全部的查询语句进行过滤,需实现IDMSLinqQueryFilter接口

6.增加直接查询SQL语句的方法,包含分页

本文链接

DMSLinq表达式框架实现(五) DMSTableExpression实现

2012-05-14T14:56:00Z

1 /// <summary>
2 /// 表的表达式处理实现
3 /// </summary>
4 public class DMSTableExpression : DMSExpressionVisitor, IDMSTableExpressionParser
5 {
6 /// <summary>
7 ///
8 /// </summary>
9 public IDMSDbProvider DbProvider
10 {
11 get;
12 set;
13 }
14 private List<SingleTableExpression> SingleExpression
15 {
16 get;
17 set;
18 }
19 /// <summary>
20 ///
21 /// </summary>
22 public Expression DMSExpression { get; set; }
23 /// <summary>
24 ///
25 /// </summary>
26 public Dictionary<string, string> KeyValue { get; set; }
27 /// <summary>
28 ///
29 /// </summary>
30 public Dictionary<string, string> TableNameAlias { get; set; }
31
32 private StringBuilder _ResultSql = new StringBuilder();
33 /// <summary>
34 ///
35 /// </summary>
36 /// <param name="keyTable"></param>
37 /// <returns></returns>
38 public string AnalyzeExpression(ref Dictionary<string, string> keyTable)
39 {
40 this._ResultSql = new StringBuilder();
41 if (DMSExpression != null)
42 {
43 this.Visit(DMSExpression);
44 }
45 keyTable = this.KeyValue;
46
47 if (keyTable.Count > 0)
48 {
49 string lastKey = keyTable.Last().Key;
50 if (TableNameAlias.ContainsKey(lastKey))
51 {
52 keyTable[lastKey] = TableNameAlias[lastKey];
53 }
54 }
55 return this._ResultSql.ToString();
56 }
57 private bool IsAs = true;
58 /// <summary>
59 ///
60 /// </summary>
61 /// <returns></returns>
62 public string AnalyzeExpression()
63 {
64 this._ResultSql = new StringBuilder();
65 this.IsAs = false;
66 if (DMSExpression != null)
67 {
68 this.Visit(DMSExpression);
69 }
70 return this._ResultSql.ToString();
71 }
72 /// <summary>
73 ///
74 /// </summary>
75 /// <param name="dms"></param>
76 /// <param name="type"></param>
77 public void Append(IDMSBase dms, Type type)
78 {
79 if (this.KeyValue == null)
80 KeyValue = new Dictionary<string, string>();
81 if (SingleExpression == null)
82 SingleExpression = new List<SingleTableExpression>();
83 if (TableNameAlias == null)
84 TableNameAlias = new Dictionary<string, string>();
85
86 if (typeof(DMSWhere) == type
87 || typeof(DMSOn) == type
88 || typeof(DMSSelect) == type)
89 {
90 if (SingleExpression.Find(q => q.Key == dms.CurrentType && q.TableType == type) != null)
91 {
92 return;
93 }
94 SingleExpression.Add(new SingleTableExpression() { Key = dms.CurrentType, TableType = type });
95 }
96 if (!type.IsGenericType && type.IsClass)
97 {
98 NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(object), Expression.New(type));
99 if (this.DMSExpression != null)
100 {
101 NewArrayExpression newArrayExpression2 = this.DMSExpression as NewArrayExpression;
102 IEnumerable<Expression> initializers2 = newArrayExpression2.Expressions.Concat(newArrayExpression.Expressions);
103 newArrayExpression = Expression.NewArrayInit(typeof(object), initializers2);
104 this.DMSExpression = dms.ModifyExpression(newArrayExpression);
105 }
106 else
107 {
108 this.DMSExpression = dms.ModifyExpression(newArrayExpression);
109 }
110 }
111 else
112 {
113 NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(object), Expression.Constant(type.ToString()));
114 if (this.DMSExpression != null)
115 {
116 Expression exp = this.DMSExpression;
117 NewArrayExpression newArrayExpression2 = exp as NewArrayExpression;
118 if (newArrayExpression2 != null)
119 {
120 IEnumerable<Expression> initializers2 = newArrayExpression2.Expressions.Concat(newArrayExpression.Expressions);
121 newArrayExpression = Expression.NewArrayInit(typeof(object), initializers2);
122 this.DMSExpression = dms.ModifyExpression(newArrayExpression);
123 }
124 }
125 else
126 {
127 this.DMSExpression = dms.ModifyExpression(newArrayExpression);
128 }
129 }
130 }
131 /// <summary>
132 ///
133 /// </summary>
134 /// <param name="nex"></param>
135 /// <returns></returns>
136 protected override NewExpression VisitNew(NewExpression nex)
137 {
138 Type type = nex.Type;
139
140 if (!type.IsGenericType && type.IsClass)
141 {
142 AdjustConstant(type);
143 }
144 #region MyRegion
145 //else
146 //{
147 // foreach (Expression exp in nex.Arguments)
148 // {
149 // this.Visit(exp);
150 // if (!this._ResultSql.ToString().EndsWith(","))
151 // {
152 // this._ResultSql.Append(",");
153 // }
154 // }
155 // if (this._ResultSql.ToString().EndsWith(","))
156 // {
157 // this._ResultSql.Remove(this._ResultSql.Length - 1, 1);
158 // }
159 // this._ResultSql.Append(" ");
160 //}
161 #endregion
162 return nex;
163 }
164 private void AdjustConstant(Type type)
165 {
166 string text = string.Empty;
167 bool IsEntity = false;
168 //是否是IEntity
169 if (type.GetInterface(typeof(IEntity).FullName, false) != null)
170 {
171 if (!this.KeyValue.ContainsKey(type.ToString()))
172 {
173 string AliasName = "t" + this.KeyValue.Count;
174 if (TableNameAlias.ContainsKey(type.ToString()))
175 {
176 AliasName = TableNameAlias[type.ToString()];
177 }
178 this.KeyValue.Add(type.ToString(), AliasName);
179 }
180 text = type.GetEntityName();
181 if (string.IsNullOrEmpty(text)) {
182 text = type.Name;
183 }
184 IsEntity = true;
185 }
186 else if (type.GetInterface(typeof(IDMSParser).FullName, false) != null)//是否是IDMSParser
187 {
188 text = type.GetDMSName();
189 if (type == typeof(DMSSelect))
190 {
191 text = "";
192 }
193 }
194 else
195 {
196 if (!this.KeyValue.ContainsKey(type.ToString()))
197 {
198 string AliasName = "t" + this.KeyValue.Count;
199 if (TableNameAlias.ContainsKey(type.ToString()))
200 {
201 AliasName = TableNameAlias[type.ToString()];
202 }
203 this.KeyValue.Add(type.ToString(), AliasName);
204 }
205 }
206 if (!string.IsNullOrEmpty(text) && this.DbProvider != null && type.GetInterface(typeof(IDMSParser).FullName, false) == null)
207 {
208 text = this.DbProvider.BuildTableName(text);
209 }
210 this._ResultSql.Append(text);
211 if (IsEntity && IsAs)
212 {
213 this._ResultSql.Append(" AS ");
214 text = this.KeyValue[type.ToString()];
215 if (!string.IsNullOrEmpty(text) && this.DbProvider != null)
216 {
217 text = this.DbProvider.BuildTableName(text);
218 }
219 this._ResultSql.Append(text);
220 }
221 this._ResultSql.Append(" ");
222 }
223 /// <summary>
224 ///
225 /// </summary>
226 /// <param name="c"></param>
227 /// <returns></returns>
228 protected override Expression VisitConstant(ConstantExpression c)
229 {
230
231 if (c.Value != null)
232 {
233 if (c.Type.IsArray)
234 {
235 Array array = c.Value as Array;
236 foreach (object current in array)
237 {
238 if (current != null)
239 {
240 Type type = current.GetType();
241 if (type == typeof(string))
242 {
243 if (!this.KeyValue.ContainsKey(current.ToString()))
244 {
245 string AliasName = "t" + this.KeyValue.Count;
246 if (this.TableNameAlias.ContainsKey(current.ToString()))
247 {
248 AliasName = this.TableNameAlias[current.ToString()];
249 }
250 this.KeyValue.Add(current.ToString(), AliasName);
251 }
252 }
253 else
254 {
255 AdjustConstant(type);
256 }
257 }
258 }
259 }
260 else
261 {
262 if (!this.KeyValue.ContainsKey(c.Value.ToString()))
263 {
264 this.KeyValue.Add(c.Value.ToString(), "t" + this.KeyValue.Count);
265 }
266 }
267 }
268 return base.VisitConstant(c);
269 }
270 /// <summary>
271 ///
272 /// </summary>
273 /// <param name="na"></param>
274 /// <returns></returns>
275 protected override Expression VisitNewArray(NewArrayExpression na)
276 {
277 foreach (Expression current in na.Expressions)
278 {
279 this.Visit(current);
280 this._ResultSql.Append(" ");
281 }
282 return na;
283 }
284 }

本文链接

DMSLinq表达式框架实现(四)

2012-05-14T01:09:00Z

这里就不写废话了.直接上代码,代码中也有注释

1 /// <summary>
2 /// 列表达式处理器
3 /// </summary>
4 public class DMSColumnExpression : DMSExpressionVisitor, IDMSColumnExpressionParser
5 {
6 /// <summary>
7 /// DB访问处理接口
8 /// </summary>
9 public IDMSDbProvider DbProvider { get; set; }
10 /// <summary>
11 /// 接口表达式
12 /// </summary>
13 public Expression DMSExpression { get; set; }
14 /// <summary>
15 /// 是否DISTINCT列
16 /// </summary>
17 public bool IsDistinct { get; set; }
18 /// <summary>
19 /// 是否TOP 1列
20 /// </summary>
21 public bool IsFirst { get; set; }
22 /// <summary>
23 /// 是否使用参数
24 /// </summary>
25 private bool bNeedParams { get; set; }
26 /// <summary>
27 ///
28 /// </summary>
29 StringBuilder _ResultSql = new StringBuilder();
30 /// <summary>
31 ///
32 /// </summary>
33 StringBuilder _MemberSql = new StringBuilder();
34 private IDMSBase dmsBase { get; set; }
35 Dictionary<string, string> KeyValue = new Dictionary<string, string>();
36 /// <summary>
37 ///
38 /// </summary>
39 private System.Reflection.MemberInfo memberInfo;
40 private IDictionary<string, object> FieldNameValuePairs
41 {
42 get;
43 set;
44 }
45 /// <summary>
46 /// 生成列查询SQL语句,并返回字段不带前缀的member
47 /// </summary>
48 /// <param name="KeyTable"></param>
49 /// <param name="member"></param>
50 /// <returns></returns>
51 public string AnalyzeExpression(Dictionary<string, string> KeyTable, out string member)
52 {
53 this.KeyValue = KeyTable;
54 this.memberInfo = null;
55 this._ResultSql = new StringBuilder();
56 this._MemberSql = new StringBuilder();
57 if (DMSExpression != null)
58 {
59 this.Visit(DMSExpression);
60 }
61 member = _MemberSql.ToString();
62 return this._ResultSql.ToString();
63 }
64 /// <summary>
65 /// UPDATE
66 /// </summary>
67 /// <param name="dbParams"></param>
68 /// <returns></returns>
69 public string AnalyzeExpression(out IDbDataParameter[] dbParams)
70 {
71 this._ResultSql = new StringBuilder();
72 int num = 0;
73 foreach (KeyValuePair<string, object> current in FieldNameValuePairs)
74 {
75 if (current.Value != null)
76 {
77 num++;
78 }
79 }
80 IDbDataParameter[] array = new IDbDataParameter[0];
81 if (bNeedParams)
82 {
83 array = new IDbDataParameter[num];
84 }
85 string[] includeColumns = new string[num];
86 string[] includeColumnValues = new string[num];
87 num = 0;
88 Type currentType = null;
89 if (dmsBase != null)
90 {
91 currentType = Type.GetType(dmsBase.CurrentType);
92 }
93 foreach (KeyValuePair<string, object> current in FieldNameValuePairs)
94 {
95 includeColumns[num] = this.DbProvider.BuildColumnName(current.Key);
96 if (bNeedParams)
97 {
98 includeColumnValues[num] = this.DbProvider.BuildParameterName(current.Key);
99 array[num] = this.DbProvider.BuildParameter(current.Key, current.Value);
100 }
101 else
102 {
103 AdjustConstant(num, ref includeColumnValues, current, currentType);
104 }
105 num++;
106 }
107
108 for (int ndx = 0; ndx < includeColumns.Length; ndx++)
109 {
110 _ResultSql.AppendFormat("{0}={1},", includeColumns[ndx], includeColumnValues[ndx]);
111 }
112 dbParams = array;
113 return this._ResultSql.ToString().TrimEnd(new char[] { ',' });
114 }
115 /// <summary>
116 /// INSERT
117 /// </summary>
118 /// <param name="parameters"></param>
119 /// <param name="dbParams"></param>
120 /// <returns></returns>
121 public string AnalyzeExpression(out string parameters, out IDbDataParameter[] dbParams)
122 {
123 this._ResultSql = new StringBuilder();
124 StringBuilder strParams = new StringBuilder();
125 int num = 0;
126 foreach (KeyValuePair<string, object> current in FieldNameValuePairs)
127 {
128 if (current.Value != null)
129 {
130 num++;
131 }
132 }
133 IDbDataParameter[] array = new IDbDataParameter[0];
134 if (bNeedParams)
135 {
136 array = new IDbDataParameter[num];
137 }
138 string[] includeColumns = new string[num];
139 string[] includeColumnValues = new string[num];
140 num = 0;
141 Type currentType = null;
142 if (dmsBase != null)
143 {
144 currentType = Type.GetType(dmsBase.CurrentType);
145 }
146 foreach (KeyValuePair<string, object> current in FieldNameValuePairs)
147 {
148 includeColumns[num] = this.DbProvider.BuildColumnName(current.Key);
149 if (bNeedParams)
150 {
151 includeColumnValues[num] = this.DbProvider.BuildParameterName(current.Key);
152 array[num] = this.DbProvider.BuildParameter(current.Key, current.Value);
153 }
154 else
155 {
156
157 AdjustConstant(num, ref includeColumnValues, current, currentType);
158 }
159 num++;
160 }
161
162 for (int ndx = 0; ndx < includeColumns.Length; ndx++)
163 {
164 _ResultSql.AppendFormat("{0},", includeColumns[ndx]);
165 strParams.AppendFormat("{0},", includeColumnValues[ndx]);
166 }
167 dbParams = array;
168 parameters = strParams.ToString().TrimEnd(new char[] { ',' });
169 return this._ResultSql.ToString().TrimEnd(new char[] { ',' });
170 }
171 /// <summary>
172 ///过滤参数值
173 /// </summary>
174 /// <param name="num"></param>
175 /// <param name="includeColumnValues"></param>
176 /// <param name="current"></param>
177 /// <param name="currentType"></param>
178 private void AdjustConstant(int num, ref string[] includeColumnValues, KeyValuePair<string, object> current, Type currentType)
179 {
180 bool IsStringType = false;
181 object value = current.Value;
182 if (currentType != null)
183 {
184 PropertyInfo propertyInfo = currentType.GetProperty(current.Key);
185 if (propertyInfo != null)
186 {
187 if (!propertyInfo.PropertyType.IsStringType())
188 {
189 IsStringType = true;
190 if (propertyInfo.PropertyType.IsBooleanType())
191 {
192 if (value != null)
193 {
194 value = (bool)value ? "1" : "0";
195 }
196 }
197 }
198 }
199 }
200 if (!IsStringType && value != null)
201 {
202 value = "'" + value.ToString().Replace("'", "''") + "'";
203 }
204 includeColumnValues[num] = value == null ? "NULL" : value.ToString();
205 }
206
207 #region Append
208 /// <summary>
209 /// 添加DMS
210 /// </summary>
211 /// <typeparam name="T"></typeparam>
212 /// <param name="dms"></param>
213 /// <param name="Body"></param>
214 public void Append<T>(IDMSBase dms, Expression Body)
215 {
216 this.dmsBase = dms;
217 if (Body is NewExpression)
218 {
219 NewExpression newExpression = Body as NewExpression;
220 if (newExpression != null)
221 {
222 Expression exp = dms.ModifyExpression(newExpression);
223 DMSExpression = exp;
224 }
225 }
226 else if (Body is MethodCallExpression)
227 {
228 MethodCallExpression methodCallExpression = Body as MethodCallExpression;
229 if (methodCallExpression != null)
230 {
231 NewArrayExpression newArrayExpression = (methodCallExpression.Arguments[1] as NewArrayExpression);
232 DMSExpression = newArrayExpression;
233 }
234 }
235 else if (Body is NewArrayExpression)
236 {
237 NewArrayExpression newArrayExpression = Body as NewArrayExpression;
238 DMSExpression = newArrayExpression;
239 }
240 }
241 /// <summary>
242 /// 单表添加一个列名
243 /// </summary>
244 /// <typeparam name="T"></typeparam>
245 /// <param name="dms"></param>
246 /// <param name="selector"></param>
247 public void Append<T>(IDMSBase dms, Expression<Func<T, T>> selector)
248 {
249 this.dmsBase = dms;
250 if (selector != null)
251 {
252 Expression body = selector.Body;
253 this.Append<T>(dms, body);
254 }
255 }
256 /// <summary>
257 /// 两表连接添加一个NEW实例
258 /// </summary>
259 /// <typeparam name="T"></typeparam>
260 /// <typeparam name="R"></typeparam>
261 /// <typeparam name="TResult"></typeparam>
262 /// <param name="dms"></param>
263 /// <param name="selector"></param>
264 public void Append<T, R, TResult>(IDMSBase dms, Expression<Func<T, R, TResult>> selector)
265 {
266 this.dmsBase = dms;
267 if (selector != null)
268 {
269 NewExpression newExpression = selector.Body as NewExpression;
270 if (newExpression != null)
271 {
272 DMSExpression = dms.ModifyExpression(newExpression);
273 }
274 }
275 else
276 {
277 NewExpression newExpression = Expression.New(typeof(TResult));
278 if (newExpression != null)
279 {
280 DMSExpression = dms.ModifyExpression(newExpression);
281 }
282 }
283 }
284 /// <summary>
285 /// 三表连接添加一个NEW实例
286 /// </summary>
287 /// <typeparam name="T"></typeparam>
288 /// <typeparam name="T1"></typeparam>
289 /// <typeparam name="T2"></typeparam>
290 /// <typeparam name="TResult"></typeparam>
291 /// <param name="dms"></param>
292 /// <param name="selector"></param>
293 public void Append<T, T1, T2, TResult>(IDMSBase dms, Expression<Func<T, T1, T2, TResult>> selector)
294 {
295 this.dmsBase = dms;
296 if (selector != null)
297 {
298 NewExpression newExpression = selector.Body as NewExpression;
299 if (newExpression != null)
300 {
301 DMSExpression = dms.ModifyExpression(newExpression);
302 }
303 }
304 }
305 /// <summary>
306 /// 添加一个NEW实例到列查询中
307 /// </summary>
308 /// <typeparam name="T"></typeparam>
309 /// <typeparam name="TReulst"></typeparam>
310 /// <param name="dms"></param>
311 /// <param name="selector"></param>
312 public void AppendResult<T, TReulst>(IDMSBase dms, Expression<Func<T, TReulst>> selector)
313 {
314 this.dmsBase = dms;
315 if (selector != null)
316 {
317 if (selector.Body is NewExpression)
318 {
319 NewExpression newExpression = selector.Body as NewExpression;
320 if (newExpression != null)
321 {
322 DMSExpression = dms.ModifyExpression(newExpression);
323 }
324 }
325 else if (selector.Body is MethodCallExpression)
326 {
327 MethodCallExpression methodCallExpression = selector.Body as MethodCallExpression;
328 if (methodCallExpression != null)
329 {
330 NewArrayExpression newArrayExpression = (methodCallExpression.Arguments[1] as NewArrayExpression);
331 DMSExpression = newArrayExpression;
332 }
333 }
334 }
335 }
336 /// <summary>
337 /// UPDATE,DELETE,INSERT字段添加组合,
338 /// </summary>
339 /// <param name="dms"></param>
340 /// <param name="bNeedParams">是否使用参数形式</param>
341 /// <param name="fieldNameValuePairs">改变字段(MAPPNG)集合</param>
342 public void Append(IDMSBase dms, bool bNeedParams, IDictionary<string, object> fieldNameValuePairs)
343 {
344 this.dmsBase = dms;
345 this.bNeedParams = bNeedParams;
346 this.FieldNameValuePairs = fieldNameValuePairs;
347 }
348 #endregion
349
350 /// <summary>
351 /// 重载访问NewExpression
352 /// </summary>
353 /// <param name="nex"></param>
354 /// <returns></returns>
355 protected override NewExpression VisitNew(NewExpression nex)
356 {
357 int ndx = 0;
358 foreach (Expression exp in nex.Arguments)
359 {
360 memberInfo = null;
361 if (nex.Members.Count > ndx)
362 {
363 memberInfo = nex.Members[ndx];
364 }
365 this.Visit(exp);
366 ndx++;
367 if (!this._ResultSql.ToString().EndsWith(","))
368 {
369 this._ResultSql.Append(",");
370 }
371 if (!this._MemberSql.ToString().EndsWith(","))
372 {
373 this._MemberSql.Append(",");
374 }
375 }
376 if (this._ResultSql.ToString().EndsWith(","))
377 {
378 this._ResultSql.Remove(this._ResultSql.Length - 1, 1);
379 }
380 this._ResultSql.Append(" ");
381 if (this._MemberSql.ToString().EndsWith(","))
382 {
383 this._MemberSql.Remove(this._MemberSql.Length - 1, 1);
384 }
385 this._MemberSql.Append(" ");
386 return nex;
387 }
388 /// <summary>
389 /// 重载访问NewArrayExpression
390 /// </summary>
391 /// <param name="na"></param>
392 /// <returns></returns>
393 protected override Expression VisitNewArray(NewArrayExpression na)
394 {
395 foreach (Expression current in na.Expressions)
396 {
397 this.Visit(current);
398 this._ResultSql.Append(",");
399 }
400 if (this._ResultSql.ToString().EndsWith(","))
401 {
402 this._ResultSql.Remove(this._ResultSql.Length - 1, 1);
403 }
404 return na;
405 }
406 /// <summary>
407 /// 重载访问MemberExpression
408 /// </summary>
409 /// <param name="m"></param>
410 /// <returns></returns>
411 protected override Expression VisitMemberAccess(MemberExpression m)
412 {
413 if (m.Expression is ParameterExpression)
414 {
415 string text = string.Empty;
416 Type valueType = m.Member.ReflectedType;
417 if (valueType != null && this.KeyValue.ContainsKey(valueType.ToString()))
418 {
419 text = this.KeyValue[valueType.ToString()];
420 if (this.DbProvider != null)
421 {
422 text = this.DbProvider.BuildColumnName(text);
423 }
424 this._ResultSql.Append(text + ".");
425 }
426
427 text = m.Member.Name;
428 if (text.StartsWith("get_", StringComparison.CurrentCultureIgnoreCase))
429 {
430 text = text.Substring(4);
431 }
432 if (this.DbProvider != null)
433 {
434 text = this.DbProvider.BuildColumnName(text);
435 }
436 this._ResultSql.Append(text);
437
438 if (this.memberInfo != null)
439 {
440 string memberName = (memberInfo.Name);
441 if (memberName.StartsWith("get_", StringComparison.CurrentCultureIgnoreCase))
442 {
443 memberName = memberName.Substring(4);
444 }
445 if (this.DbProvider != null)
446 {
447 memberName = this.DbProvider.BuildColumnName(memberName);
448 }
449 if (text != memberName)
450 {
451 this._ResultSql.Append(" AS " + memberName);
452 }
453 this._MemberSql.Append(memberName);
454 }
455 return m;
456 }
457 return base.VisitMemberAccess(m);
458 }
459 /// <summary>
460 /// 重载访问ConstantExpression
461 /// </summary>
462 /// <param name="c"></param>
463 /// <returns></returns>
464 protected override Expression VisitConstant(ConstantExpression c)
465 {
466 if (c.Value != null)
467 {
468 this._ResultSql.Append(c.Value.ToString());
469 this._ResultSql.Append(" ");
470 }
471 return base.VisitConstant(c);
472 }
473 /// <summary>
474 /// 重载访问MethodCallExpression
475 /// </summary>
476 /// <param name="m"></param>
477 /// <returns></returns>
478 protected override Expression VisitMethodCall(MethodCallExpression m)
479 {
480 if (m == null) return m;
481 string methodName = m.Method.Name;
482 MethodInfo method = typeof(DMSColumnExpression).GetMethod("Handle" + methodName);
483 if (method != null)
484 {
485 Expression exp = method.Invoke(this, new object[] { m }) as Expression;
486 return exp;
487 }
488 return base.VisitMethodCall(m);
489 }
490
491 /// <summary>
492 /// 处理COUNT(*)
493 /// </summary>
494 /// <param name="m"></param>
495 /// <returns></returns>
496 public virtual Expression HandleCountAll(MethodCallExpression m)
497 {
498 this._ResultSql.Append(" Count(*) ");
499 return m;
500 }
501 /// <summary>
502 /// 处理COUNT(列)
503 /// </summary>
504 /// <param name="m"></param>
505 /// <returns></returns>
506 public virtual Expression HandleCount(MethodCallExpression m)
507 {
508 this.MethodFunc(m.Method.Name, m);
509 return m;
510 }
511 /// <summary>
512 /// 处理LEN(列)
513 /// </summary>
514 /// <param name="m"></param>
515 /// <returns></returns>
516 public virtual Expression HandleLen(MethodCallExpression m)
517 {
518 this.MethodFunc(m.Method.Name, m);
519 return m;
520 }
521 /// <summary>
522 /// 处理MAX(列)
523 /// </summary>
524 /// <param name="m"></param>
525 /// <returns></returns>
526 public virtual Expression HandleMax(MethodCallExpression m)
527 {
528 this.MethodFunc(m.Method.Name, m);
529 return m;
530 }
531 /// <summary>
532 /// 处理MIN(列)
533 /// </summary>
534 /// <param name="m"></param>
535 /// <returns></returns>
536 public virtual Expression HandleMin(MethodCallExpression m)
537 {
538 this.MethodFunc(m.Method.Name, m);
539 return m;
540 }
541 /// <summary>
542 /// 处理AVG(列)
543 /// </summary>
544 /// <param name="m"></param>
545 /// <returns></returns>
546 public virtual Expression HandleAvg(MethodCallExpression m)
547 {
548 this.MethodFunc(m.Method.Name, m);
549 return m;
550 }
551 /// <summary>
552 /// 处理SUM(列)
553 /// </summary>
554 /// <param name="m"></param>
555 /// <returns></returns>
556 public virtual Expression HandleSum(MethodCallExpression m)
557 {
558 this.MethodFunc(m.Method.Name, m);
559 return m;
560 }
561 /// <summary>
562 /// 处理 (列) AS 别名
563 /// </summary>
564 /// <param name="m"></param>
565 /// <returns></returns>
566 public virtual Expression HandleAs(MethodCallExpression m)
567 {
568 this.Visit(m.Arguments[0]);
569 object value = LocalDMSExpressionChecker.ConvertConstantExpression(m.Arguments[1]).Value;
570 if (value != null)
571 {
572 this._ResultSql.Append(" AS ");
573 this._ResultSql.Append(this.DbProvider.LeftToken + value + this.DbProvider.RightToken);
574 }
575 return m;
576 }
577 /// <summary>
578 ///
579 /// </summary>
580 /// <param name="m"></param>
581 /// <returns></returns>
582 public virtual Expression HandleSpecialColumn(MethodCallExpression m)
583 {
584 object value = LocalDMSExpressionChecker.ConvertConstantExpression(m.Arguments[1]).Value;
585 if (value != null)
586 {
587 string text = value.ToString();
588 if (this.DbProvider != null)
589 {
590 text = this.DbProvider.BuildColumnName(text);
591 }
592 this._ResultSql.Append(text);
593 }
594 return m;
595 }
596 /// <summary>
597 /// 处理方法拼接SQL
598 /// </summary>
599 /// <param name="methodName"></param>
600 /// <param name="m"></param>
601 protected void MethodFunc(string methodName, MethodCallExpression m)
602 {
603 this._ResultSql.Append(" " + methodName + "(");
604 this.Visit(m.Arguments[0]);
605 this._ResultSql.Append(") ");
606 }
607 }

DMSLinq表达式框架实现(三)

2012-05-11T13:25:00Z

IDMSExpressionParser 相关接口

提到这个首先要考虑一下数据库多种类型的情况,也就产生了一个

IDMSDbProvider接口

1 /// <summary>
2 /// DB访问处理接口
3 /// </summary>
4 public interface IDMSDbProvider
5 {
6 TableConfiguration TableConfig { get; }
7 /// <summary>
8 /// 数据访问
9 /// </summary>
10 IDMSDbAccess DbAccess { get; }
11 /// <summary>
12 /// 参数前缀 SQL为@,ORACLE为:
13 /// </summary>
14 string ParamPrefix { get; }
15 /// <summary>
16 /// 表名,字段名的处理,像表名一般都会加[TableName],[ColumnName] 的左中括号
17 /// </summary>
18 string LeftToken { get; }
19
20 /// <summary>
21 /// 表名,字段名的处理,像表名一般都会加[TableName],[ColumnName] 的右中括号
22 /// </summary>
23 string RightToken { get; }
24 /// <summary>
25 /// 字段名处理
26 /// </summary>
27 /// <param name="name"></param>
28 /// <returns></returns>
29 string BuildColumnName(string name);
30 /// <summary>
31 /// 表名处理
32 /// </summary>
33 /// <param name="name"></param>
34 /// <returns></returns>
35 string BuildTableName(string name);
36 /// <summary>
37 /// 参数处理,返回类型为IDbDataParameter
38 /// </summary>
39 /// <param name="name"></param>
40 /// <param name="value"></param>
41 /// <returns></returns>
42 IDbDataParameter BuildParameter(string name, object value);
43 /// <summary>
44 /// 生成参数名称,这个要根据ParamPrefix来生成,也可以做特殊处理
45 /// </summary>
46 /// <param name="name"></param>
47 /// <returns></returns>
48 string BuildParameterName(string name);
49 }

我对接口进行了一下合并.其实我认为还有合并的地方.只时一时没有时间整理,先这样吧

1 /// <summary>
2 /// 所有表达式总接口
3 /// </summary>
4 public interface IDMSExpressionParser
5 {
6 IDMSDbProvider DbProvider { get; set; }
7 /// <summary>
8 /// 接口表达式
9 /// </summary>
10 Expression DMSExpression { get; set; }
11 }
12 /// <summary>
13 /// 表处理表达式
14 /// </summary>
15 public interface IDMSTableExpressionParser : IDMSExpressionParser
16 {
17 Dictionary<string, string> TableNameAlias { get; set; }
18 void Append(IDMSBase dms, Type type);
19 string AnalyzeExpression(ref Dictionary<string, string> KeyValue);
20 string AnalyzeExpression();
21 }
22 /// <summary>
23 /// 列名处理表达式,这个暂未做DISTINCT处理
24 /// </summary>
25 public interface IDMSColumnExpressionParser : IDMSExpressionParser
26 {
27 string AnalyzeExpression(Dictionary<string, string> KeyTable, out string member);
28 string AnalyzeExpression(out IDbDataParameter[] dbParams);
29 string AnalyzeExpression(out string parameters, out IDbDataParameter[] dbParams);
30 void Append<T, T1, T2, TResult>(IDMSBase dms, Expression<Func<T, T1, T2, TResult>> selector);
31 void Append<T, R, TResult>(IDMSBase dms, Expression<Func<T, R, TResult>> selector);
32 void Append<T>(IDMSBase dms, Expression<Func<T, T>> selector);
33 void Append(IDictionary<string, object> fieldNameValuePairs);
34
35 void AppendResult<T, TReulst>(IDMSBase dms, Expression<Func<T, TReulst>> selector);
36 }
37 /// <summary>
38 /// Where条件处理表达式
39 /// </summary>
40 public interface IDMSWhereExpressionParser : IDMSExpressionParser
41 {
42 string AnalyzeExpression();
43 string AnalyzeExpression(int paramIndex, out IDbDataParameter[] dbParams);
44 string AnalyzeExpression(Dictionary<string, string> keyTable);
45 string AnalyzeExpression(Dictionary<string, string> keyTable, int paramIndex, out IDbDataParameter[] dbParams);
46 void Append<T1, T2>(IDMSBase dms, Expression<Func<T1, T2, bool>> where);
47 void Append<T>(IDMSBase dms, Expression<Func<T, bool>> where);
48 void Append<T>(IDMSBase dms, DMSWhereClip<T> where) where T : IEntity;
49 }
50 /// <summary>
51 /// 排序处理表达式
52 /// </summary>
53 public interface IDMSOrderByExpressionParser : IDMSExpressionParser
54 {
55 void Append(IDMSBase dms, Type type);
56 void Append<T>(IDMSBase dms, Expression<Func<T, T>> selector);
57 string AnalyzeExpression(Dictionary<string, string> KeyTable);
58 }
59 /// <summary>
60 /// 分组处理表达式
61 /// </summary>
62 public interface IDMSGroupByExpressionParser : IDMSExpressionParser
63 {
64 string AnalyzeExpression(Dictionary<string, string> KeyTable);
65 void Append<T, TReulst>(IDMSBase dms, Expression<Func<T, TReulst>> selector);
66 void Append(IDMSBase dms, Type type);
67 }
68 /// <summary>
69 /// HAVING条件处理表达式
70 /// </summary>
71 public interface IDMSHavingExpressionParser : IDMSExpressionParser
72 {
73 void Append(IDMSBase dms, Type type);
74 void Append<T>(IDMSBase dms, Expression<Func<T, bool>> having);
75 string AnalyzeExpression(Dictionary<string, string> KeyTable);
76 }
77 /// <summary>
78 /// 表达式辅助接口
79 /// </summary>
80 public interface IDMSParser
81 {
82
83 }

接下来就是实现了..我先放个where的实现.其它的后续补上,哈!

1 public class DMSWhereExpression : DMSExpressionVisitor, IDMSWhereExpressionParser
2 {
3 public IDMSDbProvider DbProvider
4 {
5 get;
6 set;
7 }
8 private StringBuilder _ResultSql = new StringBuilder();
9 protected List<IDbDataParameter> _DbParams = new List<IDbDataParameter>();
10 public Expression DMSExpression { get; set; }
11 Dictionary<string, string> KeyValue = new Dictionary<string, string>();
12 private ExpressionType? _LastestOperator = null;
13 int _ParamIndex = 0;
14 bool _NeedParams = false;
15 private bool bConstantStartWith = false;
16 private bool bConstantEndWith = false;
17
18 private void AnalyzeExpression(bool bNeedParams, Dictionary<string, string> keyTable)
19 {
20 this.KeyValue = keyTable;
21 this._NeedParams = bNeedParams;
22 this._DbParams = new List<IDbDataParameter>();
23 this._ResultSql = new StringBuilder();
24 if (DMSExpression != null)
25 {
26 this.Visit(DMSExpression);
27 }
28 }
29 public string AnalyzeExpression()
30 {
31 return AnalyzeExpression(null);
32 }
33 public string AnalyzeExpression(Dictionary<string, string> keyTable)
34 {
35 this.AnalyzeExpression(false, keyTable);
36 return this._ResultSql.ToString();
37 }
38 public string AnalyzeExpression(Dictionary<string, string> keyTable, int paramIndex, out IDbDataParameter[] dbParams)
39 {
40 this._ParamIndex = paramIndex;
41 this.AnalyzeExpression(true, keyTable);
42 dbParams = this._DbParams.ToArray();
43 return this._ResultSql.ToString();
44 }
45 public string AnalyzeExpression(int paramIndex, out IDbDataParameter[] dbParams)
46 {
47 this._ParamIndex = paramIndex;
48 this.AnalyzeExpression(true, null);
49 dbParams = this._DbParams.ToArray();
50 return this._ResultSql.ToString();
51 }
52 public void Append<T>(IDMSBase dms, Expression<Func<T, bool>> where)
53 {
54 Expression expression = dms.ModifyExpression(where.Body);
55 if (expression != null)
56 {
57 if (this.DMSExpression != null)
58 {
59 this.DMSExpression = Expression.AndAlso(this.DMSExpression, expression);
60 }
61 else
62 {
63 this.DMSExpression = expression;
64 }
65 }
66 }
67 public void Append<T>(IDMSBase dms, DMSWhereClip<T> where) where T : IEntity
68 {
69 Expression expression = dms.ModifyExpression(where.DMSExpression);
70 if (expression != null)
71 {
72 if (this.DMSExpression != null)
73 {
74 this.DMSExpression = Expression.AndAlso(this.DMSExpression, expression);
75 }
76 else
77 {
78 this.DMSExpression = expression;
79 }
80 }
81 }
82 public void Append<T1, T2>(IDMSBase dms, Expression<Func<T1, T2, bool>> where)
83 {
84 Expression expression = dms.ModifyExpression(where.Body);
85 if (expression != null)
86 {
87 if (this.DMSExpression != null)
88 {
89 this.DMSExpression = Expression.AndAlso(this.DMSExpression, expression);
90 }
91 else
92 {
93 this.DMSExpression = expression;
94 }
95 }
96 }
97
98
99
100 protected override Expression VisitConstant(ConstantExpression c)
101 {
102 StringBuilder stringBuilder = new StringBuilder();
103 if (c.Value != null && c.Type.IsArray)
104 {
105 Array array = c.Value as Array;
106 foreach (object current in array)
107 {
108 if (current != null)
109 {
110 this.AdjustConstant(current, ref stringBuilder);
111 }
112 else
113 {
114 stringBuilder.Append("NULL");
115 }
116 stringBuilder.Append(",");
117 }
118 this._ResultSql.Append(stringBuilder.ToString().Trim(new char[] { ',' }));
119 }
120 else
121 {
122 if (c.Value != null)
123 {
124 this.AdjustConstant(c.Value, ref stringBuilder);
125 this._ResultSql.Append(stringBuilder.ToString());
126 }
127 else
128 {
129 this._ResultSql.Append("NULL");
130 }
131 }
132 return base.VisitConstant(c);
133 }
134 protected override Expression VisitMethodCall(MethodCallExpression m)
135 {
136 if (m == null) return m;
137 string methodName = m.Method.Name;
138 MethodInfo method = typeof(DMSWhereExpression).GetMethod("Handle" + methodName);
139 if (method != null)
140 {
141 if (methodName.ToUpper() == "LIKE")
142 {
143 this.bConstantStartWith = this.bConstantEndWith = true;
144 }
145 else if (methodName.ToUpper() == "STARTWITH")
146 {
147 this.bConstantStartWith = true;
148 }
149 else if (methodName.ToUpper() == "ENDWITH")
150 {
151 this.bConstantStartWith = true;
152 }
153 Expression exp = method.Invoke(this, new object[] { m }) as Expression;
154 this.bConstantStartWith = this.bConstantEndWith = false;
155 return exp;
156 }
157 return base.VisitMethodCall(m);
158 }
159 protected override Expression VisitNewArray(NewArrayExpression na)
160 {
161 foreach (Expression current in na.Expressions)
162 {
163 this.Visit(current);
164 this._ResultSql.Append(" ");
165 }
166 return na;
167 }
168 protected override Expression VisitUnary(UnaryExpression u)
169 {
170 return base.VisitUnary(u);
171 }
172 protected override Expression VisitBinary(BinaryExpression b)
173 {
174 this._ResultSql.Append("(");
175 this.Visit(b.Left);
176 this._LastestOperator = new ExpressionType?(b.NodeType);
177 this._ResultSql.Append(" " + DMSOperators.FormatBinaryOperator(this._LastestOperator) + " ");
178 this.Visit(b.Right);
179 this._ResultSql.Append(")");
180 return b;
181 }
182 protected override Expression VisitMemberAccess(MemberExpression m)
183 {
184 if (m.Expression is ParameterExpression)
185 {
186 string text = string.Empty;
187 Type valueType = m.Member.ReflectedType;
188 if (valueType != null && this.KeyValue != null && this.KeyValue.ContainsKey(valueType.ToString()))
189 {
190 text = this.KeyValue[valueType.ToString()];
191 if (this.DbProvider != null)
192 {
193 text = this.DbProvider.BuildColumnName(text);
194 }
195 this._ResultSql.Append(text + ".");
196 }
197 text = m.Member.Name;
198 if (this.DbProvider != null)
199 {
200 text = this.DbProvider.BuildColumnName(text);
201 }
202 this._ResultSql.Append(text);
203 return m;
204 }
205 return base.VisitMemberAccess(m);
206 }
207 protected virtual void AdjustConstant(object value, ref StringBuilder sb)
208 {
209
210 Type type = value.GetType();
211 if (type == typeof(string) || type == typeof(bool) || type == typeof(DateTime) || type == typeof(Guid))
212 {
213 if (bConstantStartWith)
214 {
215 value = value + "%";
216 }
217 if (bConstantEndWith)
218 {
219 value = "%" + value;
220 }
221 if (this._NeedParams && this.DbProvider != null)
222 {
223 this._ParamIndex++;
224 string text = this.DbProvider.BuildParameterName("p" + this._ParamIndex.ToString());
225 IDbDataParameter item = this.DbProvider.BuildParameter(text, value);
226 this._DbParams.Add(item);
227 sb.Append(text);
228 return;
229 }
230 if (type != typeof(bool))
231 {
232 sb.Append("'");
233 value = value.ToString().Replace("'", "''");
234 }
235 else
236 {
237 value = ((bool)value) ? "1" : "0";
238 }
239
240
241
242 sb.Append(value);
243 if (type != typeof(bool))
244 {
245 sb.Append("'");
246 return;
247 }
248 }
249 else
250 {
251 if (bConstantStartWith)
252 {
253 value = value + "%";
254 }
255 if (bConstantEndWith)
256 {
257 value = "%" + value;
258 }
259 sb.Append(value);
260 }
261 }
262
263
264 public virtual Expression HandleIn(MethodCallExpression m)
265 {
266 this._ResultSql.Append("(");
267 this.Visit(m.Arguments[0]);
268 this._ResultSql.Append(" IN (");
269 if (m.Arguments[1].Type.BaseType == typeof(DMS))
270 {
271 UnaryExpression castMethodCall = Expression.Convert(m.Arguments[1], typeof(DMS));
272 LambdaExpression exp = Expression.Lambda(castMethodCall);
273 var dynamicObject = exp.Compile();
274 var obj = dynamicObject.DynamicInvoke() as DMS;
275 this._ResultSql.Append(obj.GetResultSql().Trim());
276 }
277 else
278 this.Visit(m.Arguments[1]);
279 this._ResultSql.Append("))");
280 return m;
281 }
282 public virtual Expression HandleNotIn(MethodCallExpression m)
283 {
284 this._ResultSql.Append("(");
285 this.Visit(m.Arguments[0]);
286 this._ResultSql.Append(" NOT IN (");
287 if (m.Arguments[1].Type.BaseType == typeof(DMS))
288 {
289 UnaryExpression castMethodCall = Expression.Convert(m.Arguments[1], typeof(DMS));
290 LambdaExpression exp = Expression.Lambda(castMethodCall);
291 var dynamicObject = exp.Compile();
292 var obj = dynamicObject.DynamicInvoke() as DMS;
293 this._ResultSql.Append(obj.GetResultSql().Trim());
294 }
295 else
296 this.Visit(m.Arguments[1]);
297 this._ResultSql.Append("))");
298 return m;
299 }
300 public virtual Expression HandleLike(MethodCallExpression m)
301 {
302 this._ResultSql.Append("(");
303 this.Visit(m.Arguments[0]);
304 this._ResultSql.Append(" Like ");
305 this.Visit(m.Arguments[1]);
306 this._ResultSql.Append(")");
307 return m;
308 }
309 public virtual Expression HandleStartWith(MethodCallExpression m)
310 {
311 this._ResultSql.Append("(");
312 this.Visit(m.Arguments[0]);
313 this._ResultSql.Append(" Like ");
314 this.Visit(m.Arguments[1]);
315 this._ResultSql.Append(")");
316 return m;
317 }
318 public virtual Expression HandleEndWith(MethodCallExpression m)
319 {
320 this._ResultSql.Append("(");
321 this.Visit(m.Arguments[0]);
322 this._ResultSql.Append(" Like ");
323 this.Visit(m.Arguments[1]);
324 this._ResultSql.Append(")");
325 return m;
326 }
327
328 public virtual Expression HandleIsNull(MethodCallExpression m)
329 {
330 this._ResultSql.Append("(");
331 this.Visit(m.Arguments[0]);
332 this._ResultSql.Append(" IS NULL)");
333 return m;
334 }
335
336 public virtual Expression HandleIsNotNull(MethodCallExpression m)
337 {
338 this._ResultSql.Append("(");
339 this.Visit(m.Arguments[0]);
340 this._ResultSql.Append(" IS NOT NULL)");
341 return m;
342 }
343
344 public virtual Expression HandleCountAll(MethodCallExpression m)
345 {
346 this._ResultSql.Append(" Count(*) ");
347 return m;
348 }
349 public virtual Expression HandleCount(MethodCallExpression m)
350 {
351 this.MethodFunc(m.Method.Name, m);
352 return m;
353 }
354 public virtual Expression HandleLen(MethodCallExpression m)
355 {
356 this.MethodFunc(m.Method.Name, m);
357 return m;
358 }
359 public virtual Expression HandleMax(MethodCallExpression m)
360 {
361 this.MethodFunc(m.Method.Name, m);
362 return m;
363 }
364 public virtual Expression HandleMin(MethodCallExpression m)
365 {
366 this.MethodFunc(m.Method.Name, m);
367 return m;
368 }
369 public virtual Expression HandleAvg(MethodCallExpression m)
370 {
371 this.MethodFunc(m.Method.Name, m);
372 return m;
373 }
374 public virtual Expression HandleSum(MethodCallExpression m)
375 {
376 this.MethodFunc(m.Method.Name, m);
377 return m;
378 }
379
380 public virtual Expression HandleAs(MethodCallExpression m)
381 {
382 this.Visit(m.Arguments[0]);
383 object value = LocalDMSExpressionChecker.ConvertConstantExpression(m.Arguments[1]).Value;
384 if (value != null)
385 {
386 this._ResultSql.Append(" AS ");
387 this._ResultSql.Append(this.DbProvider.LeftToken + value + this.DbProvider.RightToken);
388 }
389 return m;
390 }
391 public virtual Expression HandleSpecialColumn(MethodCallExpression m)
392 {
393 object value = LocalDMSExpressionChecker.ConvertConstantExpression(m.Arguments[1]).Value;
394 if (value != null)
395 {
396 string text = value.ToString();
397 if (this.DbProvider != null)
398 {
399 text = this.DbProvider.BuildColumnName(text);
400 }
401 this._ResultSql.Append(text);
402 }
403 return m;
404 }
405 public virtual Expression HandleNewID(MethodCallExpression m)
406 {
407 return m;
408 }
409 protected void MethodFunc(string methodName, MethodCallExpression m)
410 {
411 this._ResultSql.Append(" " + methodName + "(");
412 this.Visit(m.Arguments[0]);
413 this._ResultSql.Append(") ");
414 }
415 public virtual Expression HandleGreaterThan(MethodCallExpression m)
416 {
417 this.CompareFunc(">", m);
418 return m;
419 }
420 public virtual Expression HandleGreaterThanOrEqual(MethodCallExpression m)
421 {
422 this.CompareFunc(">=", m);
423 return m;
424 }
425 public virtual Expression HandleLessThan(MethodCallExpression m)
426 {
427 this.CompareFunc("<", m);
428 return m;
429 }
430 public virtual Expression HandleLessThanOrEqual(MethodCallExpression m)
431 {
432 this.CompareFunc("<=", m);
433 return m;
434 }
435 protected void CompareFunc(string CompareStr, MethodCallExpression m)
436 {
437 this._ResultSql.Append("(");
438 this.Visit(m.Arguments[0]);
439 this._ResultSql.Append(" " + CompareStr + " ");
440 this.Visit(m.Arguments[1]);
441 this._ResultSql.Append(")");
442 }
443
444
445
446
447 }

DMSLinq表达式框架实现(二)

2012-05-01T09:23:00Z

DMSExpressionVisitor类重写,其实这个类就是System.Linq下面的ExpressionVisitor类,改它也是因为更好控制我们的SQL语句而已.

下面贴出代码:

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Linq.Expressions;
6 using System.Collections.ObjectModel;
7
8 namespace KingNET.DMSFrame.DMSLinq
9 {
10 public abstract class DMSExpressionVisitor
11 {
12 protected virtual Expression Visit(Expression exp)
13 {
14 if (exp == null)
15 {
16 return exp;
17 }
18 switch (exp.NodeType)
19 {
20 case ExpressionType.Add:
21 case ExpressionType.AddChecked:
22 case ExpressionType.And:
23 case ExpressionType.AndAlso:
24 case ExpressionType.ArrayIndex:
25 case ExpressionType.Coalesce:
26 case ExpressionType.Divide:
27 case ExpressionType.Equal:
28 case ExpressionType.ExclusiveOr:
29 case ExpressionType.GreaterThan:
30 case ExpressionType.GreaterThanOrEqual:
31 case ExpressionType.LeftShift:
32 case ExpressionType.LessThan:
33 case ExpressionType.LessThanOrEqual:
34 case ExpressionType.Modulo:
35 case ExpressionType.Multiply:
36 case ExpressionType.MultiplyChecked:
37 case ExpressionType.NotEqual:
38 case ExpressionType.Or:
39 case ExpressionType.OrElse:
40 case ExpressionType.RightShift:
41 case ExpressionType.Subtract:
42 case ExpressionType.SubtractChecked:
43 return this.VisitBinary((BinaryExpression)exp);
44
45 case ExpressionType.ArrayLength:
46 case ExpressionType.Convert:
47 case ExpressionType.ConvertChecked:
48 case ExpressionType.Negate:
49 case ExpressionType.NegateChecked:
50 case ExpressionType.Not:
51 case ExpressionType.Quote:
52 case ExpressionType.TypeAs:
53 return this.VisitUnary((UnaryExpression)exp);
54
55 case ExpressionType.Call:
56 return this.VisitMethodCall((MethodCallExpression)exp);
57
58 case ExpressionType.Conditional:
59 return this.VisitConditional((ConditionalExpression)exp);
60
61 case ExpressionType.Constant:
62 return this.VisitConstant((ConstantExpression)exp);
63
64 case ExpressionType.Invoke:
65 return this.VisitInvocation((InvocationExpression)exp);
66
67 case ExpressionType.Lambda:
68 return this.VisitLambda((LambdaExpression)exp);
69
70 case ExpressionType.ListInit:
71 return this.VisitListInit((ListInitExpression)exp);
72
73 case ExpressionType.MemberAccess:
74 return this.VisitMemberAccess((MemberExpression)exp);
75
76 case ExpressionType.MemberInit:
77 return this.VisitMemberInit((MemberInitExpression)exp);
78
79 case ExpressionType.New:
80 return this.VisitNew((NewExpression)exp);
81
82 case ExpressionType.NewArrayInit:
83 case ExpressionType.NewArrayBounds:
84 return this.VisitNewArray((NewArrayExpression)exp);
85
86 case ExpressionType.Parameter:
87 return this.VisitParameter((ParameterExpression)exp);
88
89 case ExpressionType.TypeIs:
90 return this.VisitTypeIs((TypeBinaryExpression)exp);
91
92 }
93 throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
94 }
95 protected virtual MemberBinding VisitBinding(MemberBinding binding)
96 {
97 switch (binding.BindingType)
98 {
99 case MemberBindingType.Assignment:
100 return this.VisitMemberAssignment((MemberAssignment)binding);
101
102 case MemberBindingType.MemberBinding:
103 return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
104
105 case MemberBindingType.ListBinding:
106 return this.VisitMemberListBinding((MemberListBinding)binding);
107
108 default:
109 throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
110 }
111 }
112 protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
113 {
114 ReadOnlyCollection<Expression> readOnlyCollection = this.VisitExpressionList(initializer.Arguments);
115 if (readOnlyCollection != initializer.Arguments)
116 {
117 return Expression.ElementInit(initializer.AddMethod, readOnlyCollection);
118 }
119 return initializer;
120 }
121 protected virtual Expression VisitUnary(UnaryExpression u)
122 {
123 Expression expression = this.Visit(u.Operand);
124 if (expression != u.Operand)
125 {
126 return Expression.MakeUnary(u.NodeType, expression, u.Type, u.Method);
127 }
128 return u;
129 }
130 protected virtual Expression VisitBinary(BinaryExpression b)
131 {
132 Expression expression = this.Visit(b.Left);
133 Expression expression2 = this.Visit(b.Right);
134 Expression expression3 = this.Visit(b.Conversion);
135 if (expression == b.Left && expression2 == b.Right && expression3 == b.Conversion)
136 {
137 return b;
138 }
139 if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
140 {
141 return Expression.Coalesce(expression, expression2, expression3 as LambdaExpression);
142 }
143 return Expression.MakeBinary(b.NodeType, expression, expression2, b.IsLiftedToNull, b.Method);
144 }
145 protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
146 {
147 Expression expression = this.Visit(b.Expression);
148 if (expression != b.Expression)
149 {
150 return Expression.TypeIs(expression, b.TypeOperand);
151 }
152 return b;
153 }
154 protected virtual Expression VisitConstant(ConstantExpression c)
155 {
156 return c;
157 }
158 protected virtual Expression VisitConditional(ConditionalExpression c)
159 {
160 Expression expression = this.Visit(c.Test);
161 Expression expression2 = this.Visit(c.IfTrue);
162 Expression expression3 = this.Visit(c.IfFalse);
163 if (expression != c.Test || expression2 != c.IfTrue || expression3 != c.IfFalse)
164 {
165 return Expression.Condition(expression, expression2, expression3);
166 }
167 return c;
168 }
169 protected virtual Expression VisitParameter(ParameterExpression p)
170 {
171 return p;
172 }
173 protected virtual Expression VisitMemberAccess(MemberExpression m)
174 {
175 Expression expression = this.Visit(m.Expression);
176 if (expression != m.Expression)
177 {
178 return Expression.MakeMemberAccess(expression, m.Member);
179 }
180 return m;
181 }
182 protected virtual Expression VisitMethodCall(MethodCallExpression m)
183 {
184 Expression expression = this.Visit(m.Object);
185 IEnumerable<Expression> enumerable = this.VisitExpressionList(m.Arguments);
186 if (expression != m.Object || enumerable != m.Arguments)
187 {
188 return Expression.Call(expression, m.Method, enumerable);
189 }
190 return m;
191 }
192 protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)
193 {
194 List<Expression> list = null;
195 int i = 0;
196 int count = original.Count;
197 while (i < count)
198 {
199 Expression expression = this.Visit(original[i]);
200 if (list != null)
201 {
202 list.Add(expression);
203 }
204 else
205 {
206 if (expression != original[i])
207 {
208 list = new List<Expression>(count);
209 for (int j = 0; j < i; j++)
210 {
211 list.Add(original[j]);
212 }
213 list.Add(expression);
214 }
215 }
216 i++;
217 }
218 if (list != null)
219 {
220 return list.AsReadOnly();
221 }
222 return original;
223 }
224 protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
225 {
226 Expression expression = this.Visit(assignment.Expression);
227 if (expression != assignment.Expression)
228 {
229 return Expression.Bind(assignment.Member, expression);
230 }
231 return assignment;
232 }
233 protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
234 {
235 IEnumerable<MemberBinding> enumerable = this.VisitBindingList(binding.Bindings);
236 if (enumerable != binding.Bindings)
237 {
238 return Expression.MemberBind(binding.Member, enumerable);
239 }
240 return binding;
241 }
242 protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)
243 {
244 IEnumerable<ElementInit> enumerable = this.VisitElementInitializerList(binding.Initializers);
245 if (enumerable != binding.Initializers)
246 {
247 return Expression.ListBind(binding.Member, enumerable);
248 }
249 return binding;
250 }
251 protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)
252 {
253 List<MemberBinding> list = null;
254 int i = 0;
255 int count = original.Count;
256 while (i < count)
257 {
258 MemberBinding memberBinding = this.VisitBinding(original[i]);
259 if (list != null)
260 {
261 list.Add(memberBinding);
262 }
263 else
264 {
265 if (memberBinding != original[i])
266 {
267 list = new List<MemberBinding>(count);
268 for (int j = 0; j < i; j++)
269 {
270 list.Add(original[j]);
271 }
272 list.Add(memberBinding);
273 }
274 }
275 i++;
276 }
277 if (list != null)
278 {
279 return list;
280 }
281 return original;
282 }
283 protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)
284 {
285 List<ElementInit> list = null;
286 int i = 0;
287 int count = original.Count;
288 while (i < count)
289 {
290 ElementInit elementInit = this.VisitElementInitializer(original[i]);
291 if (list != null)
292 {
293 list.Add(elementInit);
294 }
295 else
296 {
297 if (elementInit != original[i])
298 {
299 list = new List<ElementInit>(count);
300 for (int j = 0; j < i; j++)
301 {
302 list.Add(original[j]);
303 }
304 list.Add(elementInit);
305 }
306 }
307 i++;
308 }
309 if (list != null)
310 {
311 return list;
312 }
313 return original;
314 }
315 protected virtual Expression VisitLambda(LambdaExpression lambda)
316 {
317 Expression expression = this.Visit(lambda.Body);
318 if (expression != lambda.Body)
319 {
320 return Expression.Lambda(lambda.Type, expression, lambda.Parameters);
321 }
322 return lambda;
323 }
324 protected virtual NewExpression VisitNew(NewExpression nex)
325 {
326 IEnumerable<Expression> enumerable = this.VisitExpressionList(nex.Arguments);
327 if (enumerable == nex.Arguments)
328 {
329 return nex;
330 }
331 if (nex.Members != null)
332 {
333 return Expression.New(nex.Constructor, enumerable, nex.Members);
334 }
335 return Expression.New(nex.Constructor, enumerable);
336 }
337 protected virtual Expression VisitMemberInit(MemberInitExpression init)
338 {
339 NewExpression newExpression = this.VisitNew(init.NewExpression);
340 IEnumerable<MemberBinding> enumerable = this.VisitBindingList(init.Bindings);
341 if (newExpression != init.NewExpression || enumerable != init.Bindings)
342 {
343 return Expression.MemberInit(newExpression, enumerable);
344 }
345 return init;
346 }
347 protected virtual Expression VisitListInit(ListInitExpression init)
348 {
349 NewExpression newExpression = this.VisitNew(init.NewExpression);
350 IEnumerable<ElementInit> enumerable = this.VisitElementInitializerList(init.Initializers);
351 if (newExpression != init.NewExpression || enumerable != init.Initializers)
352 {
353 return Expression.ListInit(newExpression, enumerable);
354 }
355 return init;
356 }
357 protected virtual Expression VisitNewArray(NewArrayExpression na)
358 {
359 IEnumerable<Expression> enumerable = this.VisitExpressionList(na.Expressions);
360 if (enumerable == na.Expressions)
361 {
362 return na;
363 }
364 if (na.NodeType == ExpressionType.NewArrayInit)
365 {
366 return Expression.NewArrayInit(na.Type.GetElementType(), enumerable);
367 }
368 return Expression.NewArrayBounds(na.Type.GetElementType(), enumerable);
369 }
370 protected virtual Expression VisitInvocation(InvocationExpression iv)
371 {
372 IEnumerable<Expression> enumerable = this.VisitExpressionList(iv.Arguments);
373 Expression expression = this.Visit(iv.Expression);
374 if (enumerable != iv.Arguments || expression != iv.Expression)
375 {
376 return Expression.Invoke(expression, enumerable);
377 }
378 return iv;
379 }
380 }
381 }

DMSLinq表达式框架实现(一)

2012-05-01T08:30:00Z

好久没有写东西了,不是自己不想写,是自己好像对语文描述能力确实有点差劲.进园子那么久也没有写过完全是自己的东西.都快用

COPY,PARSTER用到极致了.
也罢,就把最近用的东西写写吧.
最近研究了一下LINQ表达式的一些编程方式,了解ExpressionVisitor类的主要功能及其实现.从而写了一个自己的LINQ框架,用LINQ的方式编程

进而生成相应的SQL语句来达到访问数据库的目的.其写法类似于IEnumerable<T>的写法.下面是相关例子

var person = DMS.Create<Student>().Join(DMS.Create<Person>(), (x, y) => x.PersonID == y.PersonID
, (x, y) => new { x.PersonID, x.Remark, x.StudentID, y.Name, y.Age });

调用 person.GetResultSql()

生成的Sql如下:

SELECT [t0].[PersonID],[t0].[Remark],[t0].[StudentID],[t1].[Name],[t1].[Age] FROM [Student] AS [t0] INNER JOIN [Person] AS [t1] ON
([t0].[PersonID] = [t1].[PersonID])

下面是两个相关的类:

1 [TableMapping(Name = "Person", PrimaryKey = "PersonID", DefaultOrderBy = " PersonID Desc")]
2 public class Person : BaseEntity
3 {
4 [ColumnMapping(Name = "PersonID")]
5 public int PersonID { get; set; }
6 [ColumnMapping(Name = "Name")]
7 public string Name { get; set; }
8 [ColumnMapping(Name = "Age")]
9 public int Age { get; set; }
10 }
11
12 [TableMapping(Name = "Student", PrimaryKey = "StudentID", DefaultOrderBy = " StudentID Desc")]
13 public class Student : BaseEntity
14 {
15 [ColumnMapping(Name = "StudentID")]
16 public int StudentID { get; set; }
17 [ColumnMapping(Name = "PersonID")]
18 public int PersonID { get; set; }
19 [ColumnMapping(Name = "Remark")]
20 public string Remark { get; set; }
21 }

这里建立Mapping主要是为确定列名和表名,当然我们也可以直接使用PropertyInfo.Name来进行替代..

List<DMS> list = new List<DMS>();
var a = DMS.Create<Person>()
.Where(q => q.PersonID == 0)
.OrderBy(q => q.Columns(q.PersonID));
list.Add(a);
var b = DMS.Create<Person>().Select(q => q.Columns(q.Age, q.Name, q.PersonID));
list.Add(b);

var c = DMS.Create<Person>(false)
.Where(q => q.Name.Like("123"))
.Select();

list.Add(c);

var d = DMS.Create<Person>()
.Join(DMS.Create<Student>()
, (x, y) => x.PersonID == y.PersonID
, (x, y) => new
{
x.PersonID,
x.Name,
x.Age,
y.Remark,
y.StudentID,
PersonID2 = y.PersonID
}).OrderBy(q => q.OrderBy(q.PersonID.Desc())).Pager(5, 20);
list.Add(d);
foreach (DMS item in list)
{
Console.WriteLine(item.GetResultSql());
}
Console.ReadLine();

这些只是这个DMSLINQ的一些简单功能,DMSLinq还可以生成更复杂的SQL语句.这里就不再叙述了..哈哈..

后续文章将为您慢慢揭开DMSLinq的奥秘.....

相关项目下载可以联系本人QQ.因花的时间比较多在这块.

因现在项目大部分还是3.5特此做了一个3.5版本的,调试了一上基本正常

帮助文档:

DMSLinq CHMD帮助文档

DMSLinq 示例

本文链接

根据表中数据生成insert语句的存储过程

2012-03-07T03:43:00Z

create proc spgeninsertsql (@tablename varchar(256))
as
begin
declare @sql varchar(8000)
declare @sqlvalues varchar(8000)
set @sql = (
set @sqlvalues = values (+
select @sqlvalues = @sqlvalues + cols + + , + ,@sql = @sql + [ + name + ],
from
(select case
when xtype in (48,52,56,59,60,62,104,106,108,122,127)
then case when + name + is null then null else + cast(+ name + as varchar)+ end
when xtype in (58,61)
then case when + name + is null then null else + + + cast(+ name + as varchar)+ ++ end
when xtype in (167)
then case when + name + is null then null else + + + replace(+ name+,,) + ++ end
when xtype in (231)
then case when + name + is null then null else +n + + replace(+ name+,,) + ++ end
when xtype in (175)
then case when + name + is null then null else + + + cast(replace(+ name+,,) as char( + cast(length as varchar) + ))++ end
when xtype in (239)
then case when + name + is null then null else +n + + cast(replace(+ name+,,) as char( + cast(length as varchar) + ))++ end
else null
end as cols,name
from syscolumns
where id = object_id(@tablename)
) t
set @sql =select insert into [+ @tablename + ] + left(@sql,len(@sql)-1)+) + left(@sqlvalues,len(@sqlvalues)-4) + ) from +@tablename
--print @sql
exec (@sql)
end
go

本文链接

每个好架构师都是一位出色的程序员

2012-02-16T01:54:00Z

一个优秀的软件架构师，首先一定是一个出色的程序员，这是本篇文章的议题。从本文我们可以了解到一个架构师的工作是什么，他容易遇到的问题是什么，因此他为什么必须是一个出色的程序员。

【独家特稿】架构师，听起来是如此神秘的一个称号。尤其是在开发领域刚入门不久的菜鸟级程序员眼中，架构师都是高手，都是牛人，都是如此高高在上的存在。

不过，在搞了四、五年编程之后，程序员们往往早已失去了当年对这些“高级”职位的神秘感，甚至会对自己所在项目的架构师抱怨不已，背后里称他们是一群水王。所以有江南白衣曾撰文述说：“国内的架构师到了三十岁以后很多就往理论上跑，而国外的架构师在往上发展的同时保持下面的编程体验，所以国内多水王，而国外则多大师。”

这就是我们今天这篇文章的论题：一个优秀的软件架构师，首先一定是一个出色的程序员。

这句话按照Fred George先生的话来说，那就是“不编程的架构师的职业生涯是短暂的”。他说这句话的背景主要是针对有些架构师的设计与实现有断层的问题而言的，因为如果架构师不去实践，只是想当然的认为“没问题，这个想法能实现”，那么对于项目的落实而言是个很大的隐患。支付宝架构师冯大辉也表示过，架构师是一个比较“虚”的岗位，主要的问题都在“落地”的过程中。

而一个架构师确认一个想法究竟能不能落地的最直接的方法，就是自己编写代码，尝试“实现一个系统最难实现的一部分”（Fred George）。看看Fred，他自己就是最好的示范：年纪一大把了，仍然每天都在编写代码。事实上，我们可以列举出一个长长的顶级架构师的列表，你会发现他们没有一个不是顶级的程序员。

我们可以列举出一个长长的顶级架构师的列表，你会发现他们没有一个不是顶级的程序员

不过这在逻辑上或许没有多少说服力，因为似乎这并不能证明一位资深架构师凭自己的经验感觉不能够知道一个想法能不能落实。如果你觉得上面这些只是某些西方老头儿对编程的古怪癖好，那么不妨看看eBay的架构师Randy Shoup先生是如何总结架构师在项目中的职责的：

1. 产品团队要做一个新产品，架构师开工了。架构师要帮助产品团队把可行性、技术需求以及权衡取舍等因素一一剖析清楚。

2. 技术需求出来了，架构师的主要工作开始了：设计整体的技术实现步骤。Randy在后面补充说“大多数成功的架构师都喜欢与其他团队成员一同完成架构和设计这一块的工作”，而认为自己应独自完成这个步骤则是新手架构师常见的误区。

3. 与开发团队一起，完成设计与实施的细节

4. 与开发团队和运维团队一起，完成部署的过程

5. 与运维团队一起，进行部署之后的维护和故障排除

在这个过程中，一个架构师至少有一半以上的工作是需要与开发团队一起进行的。按照Randy的描述，这是“一个架构师不能将实施细节抛之脑后”的体现。而且与开发团队一起工作，命令式的领导方式并不被推崇，一个架构师必须通过自己的个人影响力来对开发团队进行指导工作。而什么是影响力？说的直白一些，就是通过自己写代码以及和其他成员一起写代码，来指导团队成员实现每个架构细节的思路。

只要稍微思考一下，就会明白此举的重要性。如果一个架构师靠命令管理开发团队，告诉他们“要实现这个模块”，“要实现那个功能”，而团队也尝试照办。可是或许是架构师的要求太高了，或许是团队的开发实力不够，团队成员便会向架构师求助：您看这个我们不知道如何实现，您能否指导一下？架构师可能知道怎么处理，也可能没有仔细思考过这个问题，但又觉得自己做大事者不拘泥于小节也，于是一皱眉头扔下一句：这是你们的事，你们自己解决！

然后就是矛盾的开始了。架构师只觉得团队技术不够，而团队则对架构师愈发不满。项目黄了不说，开发团队中也会传出各种说法，比如说“此君其实是个一行代码也不会写的大忽悠！”

综上所述，便映证了Fred的那句断言：“不编程的架构师的职业生涯是短暂的”。一个架构师不仅要会写代码，还必须要能够写出自己设计的系统中最难实现的那段代码。这样他才能够放心的把“落地”的这个重担交给开发团队来做。

让我用Fred的这句话做为本篇的总结：“一个架构师的价值在于，他不仅能看到系统的美，而且能够在建造系统的时候能够把这些美创造出来。”

是的，每个好架构师都是一位出色的程序员。

本文链接

面试的那些事(1)

2012-02-16T01:45:00Z

前几日面试一家公司问到海量数据的问题.自己当时可能没有理解出什么意思,回答得不尽如意

上网查了查资料,发觉网上的答案众多,有点笼统.现总结一下.

1.建立相关聚合索引(查询字段用得较多)

2.在数据库上面X表的某时间字段上进行分文件,分区,优化数据库结构

3.至少也得具备常识性的数据库知道,如char比varchar查询快,char占用空间要varchar大(这个当然是以char没有填充满的情况)

4.建立数据仓库(Data Warehouse),怎么建那可能要似数据库情况而定.

列出相关文章:

1.海量数据库解决方案2011050601

本文链接

关于jquery.placeholder使用的一些小BUG

2012-02-16T01:29:00Z

相信很多朋友都用过jquery.placeholder.js这个插件,在使用中自己也碰到过这样的问题.就是如果有页面有服务器LinkButton的时候,插件bind的submit方法就失效了,我是这样解决的,如果你有更好的解决方案一起探讨!

$(".submitCal").bind('change', function() {
$("[placeholder]").each(function() {
var input = $(this);
if (input.val() == input.attr("placeholder")) {
input.val("");
}
});
});
$(".submitLink").bind('click', function() {
$("[placeholder]").each(function() {
var input = $(this);
if (input.val() == input.attr("placeholder")) {
input.val("");
}
});
});

其实就是link点击的时候去验证文本框到底有没有填写值而已.

本文链接