T4 模板代码示例

<#@ template language="C#" debug="true" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Diagnostics" #>

<#@ output extension=".cs"#>
<#

// This needs to be set to the .edmx file that you want to process.
//string edmxFile = FindEDMXFileName(); // @"Model1.edmx";
string edmxFile = @"Model.edmx";
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
MetadataTools ef = new MetadataTools(this);

#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions; 

namespace <#= code.VsNamespaceSuggestion() #>
{ 
	public interface IRepository<T> 
    {
		IUnitOfWork UnitOfWork { get; set; }
		bool IsUseDataFilter{get;set;}
		IQueryable<T> All();
		IQueryable<T> Find(Expression<Func<T, bool>> expression);
		IQueryable<T> Find(string where , params object[] para);
		IQueryable<T> Sort(IQueryable<T> source, string sortfield);
		void Add(T entity);
		void Delete(T entity);
		void Save();
		void Update(T entity);
    }
}<#


EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(edmxFile);
EntityContainer container = ItemCollection.GetItems<EntityContainer>().FirstOrDefault();
EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{;
    fileManager.StartNewFile(entity.Name + "Repository.Generated.cs"); #>using System;
using System.Linq;
using System.Collections.Generic;

// This file is auto generated and will be overwritten as soon as the template is executed
// Do not modify this file...
	
namespace <#= code.VsNamespaceSuggestion() #>
{   
	<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#>Repository
	{
		private IRepository<<#=code.Escape(entity)#>> _repository {get;set;}
		private bool _isUseDataFilter;
		public IRepository<<#=code.Escape(entity)#>> Repository
		{
			get { return _repository; }
			set { _repository = value; }
		}
		
		public <#=code.Escape(entity)#>Repository(IRepository<<#=code.Escape(entity)#>> repository, IUnitOfWork unitOfWork)
    	{
    		Repository = repository;
			Repository.UnitOfWork = unitOfWork;
			IsUseDataFilter = true;
    	}
		
		public IQueryable<<#=code.Escape(entity)#>> All()
		{
			return Repository.All();
		}

		public void Add(<#=code.Escape(entity)#> entity)
		{
			throw new NotImplementedException("This repository does not support the method.");
		}
		
		public void Delete(<#=code.Escape(entity)#> entity)
		{
			throw new NotImplementedException("This repository does not support the method.");
		}

		public void Save()
		{
			throw new NotImplementedException("This repository does not support the method.");
		}
		
		public bool IsUseDataFilter
        {
            get
            {
                return _isUseDataFilter;
            }
            set
            {
                _isUseDataFilter = value;
				this.Repository.IsUseDataFilter = value;
            }
        }
	}
}<#	
	if(!DoesFileExist(entity.Name + "Repository.cs"))
	{
		fileManager.StartNewFile(entity.Name + "Repository.cs");
		#>using System;
using System.Linq;
using System.Collections.Generic;
	
namespace <#= code.VsNamespaceSuggestion() #>
{   
	<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#>Repository
	{
		// Add your own data access methods.
		// This file should not get overridden
	}
}<#
	}
	else
	{
		fileManager.StartNewFile(entity.Name + "Repository.cs");
		this.Write(OutputFile(entity.Name + "Repository.cs"));
	}
}

fileManager.StartNewFile("IUnitOfWork.cs");
#>using System.Data.Objects;

namespace <#= code.VsNamespaceSuggestion() #>
{
	public interface IUnitOfWork
	{
		ObjectContext Context { get; set; }
		void Save();
		bool LazyLoadingEnabled { get; set; }
		bool ProxyCreationEnabled { get; set; }
		string ConnectionString { get; set; }
	}
}<#	fileManager.StartNewFile("RepositoryIQueryableExtensions.cs");
#>using System.Data.Objects;
using System.Linq;

namespace <#= code.VsNamespaceSuggestion() #>
{
	public static class RepositoryIQueryableExtensions
	{
		public static IQueryable<T> Include<T>
			(this IQueryable<T> source, string path)
		{
			var objectQuery = source as ObjectQuery<T>;
			if (objectQuery != null)
			{
				return objectQuery.Include(path);
			}
			return source;
		}
	}
}<# fileManager.StartNewFile("EFRepository.cs");
#>using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Linq;
using System.Text;
using System.Linq.Dynamic;
using System.Linq.Expressions;
using SCM.SCMEntity;

namespace <#= code.VsNamespaceSuggestion() #>
{
	public class EFRepository<T> : IRepository<T> where T : class
	{
		public IUnitOfWork UnitOfWork { get; set; }
		public bool IsUseDataFilter { get; set; }
		private IObjectSet<T> _objectset;
		private IObjectSet<T> ObjectSet
		{
			get
			{
				if (_objectset == null)
				{
					_objectset = UnitOfWork.Context.CreateObjectSet<T>();
				}
				return _objectset;
			}
		}

        public virtual void Update(T entity)
        {
            
            UnitOfWork.Context.ApplyCurrentValues<T>(typeof(T).Name,entity);
            UnitOfWork.Save();
        }

		public virtual IQueryable<T> All()
		{
			IQueryable<T> iq = ObjectSet.AsQueryable(); ;
			
            ApplyDataFilter(ref iq);
            
            return iq;
		}

		public IQueryable<T> Find(string where , params object[] paras)
        {
            IQueryable<T> iq =ObjectSet.Where(where , paras).AsQueryable();

            ApplyDataFilter(ref iq);

			return iq;
        }
		
		public IQueryable<T> Find(Expression<Func<T, bool>> expression)
		{
			IQueryable<T> iq = ObjectSet.Where<T>(expression).AsQueryable();

            ApplyDataFilter(ref iq);

			return iq;
		}

		public IQueryable<T> Sort(IQueryable<T> source,string sortfield)
        {
            return source.OrderBy(sortfield);
        }

		public void Add(T entity)
		{
			ObjectSet.AddObject(entity);
		}

		public void Delete(T entity)
		{
			ObjectSet.DeleteObject(entity);
		}

		public void Save()
		{
			UnitOfWork.Save();
		}

        private void ApplyDataFilter(ref IQueryable<T> iq)
        {
            if (IsUseDataFilter==null||!IsUseDataFilter)
                return;

            var context = new SCM.SCMEntity.SCMEntity();
            IObjectSet<sysDataFilter> _df = context.CreateObjectSet<sysDataFilter>();
			
            if (System.Web.HttpContext.Current == null)
                return;
            
            if (System.Web.HttpContext.Current.Session["userid"] == null)
                return;

            string userid=System.Web.HttpContext.Current.Session["userid"].ToString();

            List<sysDataFilter> dfs =_df.Where<sysDataFilter>(p=>p.UserID==userid&&p.TableID==typeof(T).Name).AsQueryable<sysDataFilter>().ToList();;
            var totalexp = iq.Expression;
            
            if (dfs == null)
                return;
            
            if (dfs.Count > 0)
            {
                var para = Expression.Parameter(typeof(T), "p");
                foreach (sysDataFilter df in dfs)
                {
                    var bin = Expression.Property(para, df.FieldName);
                    
                    Type t=bin.Type;
                    #region Calculate expression
                    switch (df.FOperator)
                    {
                        case "=":
                            
                            var con1 = Expression.Constant(df.FParameter,bin.Type);
                            var bin1 = Expression.Equal(bin, con1);
                            var ex1 = Expression.Lambda<Func<T, bool>>(bin1, para);
							try
							{
								switch(df.AndOr.ToLower())
								{
									case "and":
										totalexp = Expression.And(bin1, totalexp);
										break;
									case "or":
										totalexp = Expression.Or(bin1,totalexp);
										break;
									default:
										totalexp=bin1;
										break;
								}
							}catch { totalexp = bin1;}
                            break;
                        case ">":
                            
                            var con2 = Expression.Constant(df.FParameter, bin.Type);
                            var bin2 = Expression.GreaterThan(bin, con2);
                            var ex2 = Expression.Lambda<Func<T, bool>>(bin2, para);
							try
							{
								switch (df.AndOr.ToLower())
								{
									case "and":
										totalexp = Expression.And(bin2, totalexp);
										break;
									case "or":
										totalexp = Expression.Or(bin2, totalexp);
										break;
									default:
										totalexp = bin2;
										break;
								}
                            }catch { totalexp = bin2;}
                            //iq = iq.Where<T>(ex2).AsQueryable();
                            break;
                        case "<":
                            
                            var con3 = Expression.Constant(df.FParameter, bin.Type);
                            var bin3 = Expression.LessThan(bin, con3);
                            var ex3 = Expression.Lambda<Func<T, bool>>(bin3, para);
							try{
                            switch (df.AndOr.ToLower())
                            {
                                case "and":
                                    totalexp = Expression.And(bin3, totalexp);
                                    break;
                                case "or":
                                    totalexp = Expression.Or(bin3, totalexp);
                                    break;
                                default:
                                    totalexp = bin3;
                                    break;
                            }
                            }catch { totalexp = bin3;}
                            //iq = iq.Where<T>(ex3).AsQueryable();
                              break;
                              case "<>":

                              var con6 = Expression.Constant(df.FParameter, bin.Type);
                              var bin6 = Expression.LessThan(bin, con6);
                              var ex6 = Expression.Lambda<Func<T, bool>>(bin6, para);
                                try{
                                switch (df.AndOr.ToLower())
                                {
                                case "and":
                                totalexp = Expression.And(bin6, totalexp);
                                break;
                                case "or":
                                totalexp = Expression.Or(bin6, totalexp);
                                break;
                                default:
                                totalexp = bin6;
                                break;
                                }
                                }catch { totalexp = bin6;}
                                //iq = iq.Where<T>(ex6).AsQueryable();
                                  break;
                                  case "StartWith":
                                  var con4 = Expression.Constant(df.FParameter);
                                  var bin4 = Expression.LessThan(bin, con4);
                                  var ex4 = Expression.Lambda<Func<T, bool>>(bin4, para);
							try{
                            switch (df.AndOr.ToLower())
                            {
                                case "and":
                                    totalexp = Expression.And(bin4, totalexp);
                                    break;
                                case "or":
                                    totalexp = Expression.Or(bin4, totalexp);
                                    break;
                                default:
                                    totalexp = bin4;
                                    break;
                            }
                            }catch { totalexp = bin4;}
                            //iq = iq.Where<T>(ex4).AsQueryable();
                            break;
                        case "EndWith":
                            var con5 = Expression.Constant(df.FParameter);
                            var bin5 = Expression.LessThan(bin, con5);
                            var ex5 = Expression.Lambda<Func<T, bool>>(bin5, para);
							try{
                            switch (df.AndOr.ToLower())
                            {
                                case "and":
                                    totalexp = Expression.And(bin5, totalexp);
                                    break;
                                case "or":
                                    totalexp = Expression.Or(bin5, totalexp);
                                    break;
                                default:
                                    totalexp = bin5;
                                    break;
                            }
							}catch { totalexp = bin5;}
                            break;
                    }
                    #endregion
                }
                var exfinal = Expression.Lambda<Func<T, bool>>(totalexp, para);
                
                iq = iq.Where<T>(exfinal).AsQueryable();
            }
        }
	}
}<#fileManager.StartNewFile("EFUnitOfWork.cs");
#>using System.Data.Objects;

namespace <#= code.VsNamespaceSuggestion() #>
{
	public class EFUnitOfWork : IUnitOfWork
	{
		public ObjectContext Context { get; set; }

		public EFUnitOfWork()
		{
			Context = new <#=code.Escape(container)#>();
			Context.CommandTimeout=1800;
		}

		public EFUnitOfWork(int count)
		{
			Context = new <#=code.Escape(container)#>();
            Context.CommandTimeout = count;
		}
		
		public void Save()
		{
			Context.SaveChanges();
		}
		
		public bool LazyLoadingEnabled
		{
			get { return Context.ContextOptions.LazyLoadingEnabled; }
			set { Context.ContextOptions.LazyLoadingEnabled = value;}
		}

		public bool ProxyCreationEnabled
		{
			get { return Context.ContextOptions.ProxyCreationEnabled; }
			set { Context.ContextOptions.ProxyCreationEnabled = value; }
		}
		
		public string ConnectionString
		{
			get { return Context.Connection.ConnectionString; }
			set { Context.Connection.ConnectionString = value; }
		}
	}
}<#	fileManager.Process();
#>


<#+

bool DoesFileExist(string filename)
{			
	return File.Exists(Path.Combine(GetCurrentDirectory(),filename));	
}

string OutputFile(string filename)
{
	using(StreamReader sr = new StreamReader(Path.Combine(GetCurrentDirectory(),filename)))
	{
		string contents = sr.ReadToEnd();
		return contents;
	}
}

string GetCurrentDirectory()
{
	string executingDirectoryName = "";
	string stackTraceFileName = new StackTrace(true).GetFrame(0).GetFileName();
	if (String.IsNullOrEmpty(stackTraceFileName))
	{
		throw new ArgumentException("No value was specified for the ‘directoryName‘ configuration parameter" +
			", and we could not figure out the file name from the stack trace (most likely because of running " +
			"the template with debug=‘False‘ specified in the <\u0023@ template \u0023> directive.");
	}
	else
	{		
		executingDirectoryName = Path.GetDirectoryName(stackTraceFileName);
	}	
	return executingDirectoryName;
}

string FindEDMXFileName()
{
	string edmxFile = "";
				
	string[] entityFrameworkFiles = Directory.GetFiles(GetCurrentDirectory(), "*.edmx");
	if(entityFrameworkFiles.Length > 0)
		edmxFile = entityFrameworkFiles[0];
	
	return edmxFile;
}
#>