public void Send(MemoryStream stream, ProtocolEntity protocolEntity)
{
var key = ClientKey(protocolEntity.LocalHostName, protocolEntity.LocalPort, protocolEntity.RemoteHostName, protocolEntity.RemotePort);
stream.Seek(0, SeekOrigin.Begin);
System.Net.Sockets.TcpClient client = null;
if (Clients.ContainsKey(key))
{
client = Clients[key];
if (IsConnected(client))
{
stream.CopyTo(client.GetStream());
return;
}
}
else
{
client = new System.Net.Sockets.TcpClient(new IPEndPoint(IPAddress.Parse(protocolEntity.LocalHostName), protocolEntity.LocalPort));
Clients[key] = client;
}
var state = new ClientBegin {
Sender = this, Client = client, stream = stream
};
client.BeginConnect(protocolEntity.RemoteHostName, protocolEntity.RemotePort, (ar) =>
{
var s = ar.AsyncState as ClientBegin;
s.stream.Seek(0, SeekOrigin.Begin);
s.stream.CopyTo(s.Client.GetStream());
}, state);
}
private void GenerateProtocolEntity(String baseFolder, IList <FrameworkEntity> entities, Framework f, FrameworkEntity e, String sourcePath, String destinationPath)
{
String file;
ProtocolEntity entity = BaseEntity.LoadFrom <ProtocolEntity> (sourcePath);
if (!entity.Generate)
{
return;
}
this.Log(Level.Info, String.Format("Generating '{0}'...", e.name));
this.LoadProtocolDependencies(baseFolder, entities, entity);
file = destinationPath + ".Protocol.cs";
this.Generate <ProtocolGenerator> (f, entity, file);
if (entity.DelegatorEntity != null)
{
String property = entity.DelegateProperty ?? "Delegate";
String dir = Path.GetDirectoryName(destinationPath);
file = Path.Combine(dir, entity.DelegatorEntity.Name + "." + property + ".cs");
this.Generate <ClassDelegateGenerator> (f, entity, file);
}
if (entity.HasConstants || entity.HasEnumerations)
{
file = destinationPath + ".Constants.cs";
this.Generate <ClassConstantsGenerator> (f, entity, file);
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveForm(string keyValue, ProtocolEntity entity)
{
try
{
service.SaveForm(keyValue, entity);
}
catch (Exception)
{
throw;
}
}
private void Convert(Framework f, FrameworkEntity e, String sourcePath, String destinationPath, TextWriter writer = null)
{
switch (e.type)
{
case FrameworkEntityType.T:
{
IXhtmlTypeParser parser = this.GetTypeParser(f, e, writer);
TypedEntity entity = new TypedEntity();
entity.Namespace = f.name;
entity.Name = e.name;
entity.Nature = e.type;
parser.Parse(entity, sourcePath);
entity.SaveTo(destinationPath);
}
break;
case FrameworkEntityType.C:
{
IXhtmlClassParser parser = this.GetClassParser(f, e, writer);
ClassEntity entity = new ClassEntity();
entity.Namespace = f.name;
entity.Name = e.name;
entity.Nature = e.type;
parser.Parse(entity, sourcePath);
entity.SaveTo(destinationPath);
}
break;
case FrameworkEntityType.P:
{
IXhtmlClassParser parser = this.GetProtocolParser(f, e, writer);
ProtocolEntity entity = new ProtocolEntity();
entity.Namespace = f.name;
entity.Name = e.name;
entity.Nature = e.type;
parser.Parse(entity, sourcePath);
entity.SaveTo(destinationPath);
}
break;
default:
break;
}
}
private void LoadClassDependencies(String baseFolder, IList <FrameworkEntity> entities, ClassEntity classEntity)
{
if (classEntity == null)
{
return;
}
this.Log(Level.Verbose, "Loading class dependencies for " + classEntity.Name);
// Retrieve super class
ClassEntity baseTypeEntity = this.FindAndLoad <ClassEntity>(baseFolder, entities, FrameworkEntityType.C, classEntity.BaseType);
this.Log(Level.Verbose, "Base type for " + classEntity.Name + " is " + baseTypeEntity);
if (baseTypeEntity != null)
{
this.LoadClassDependencies(baseFolder, entities, baseTypeEntity);
classEntity.SuperClass = baseTypeEntity;
}
this.Log(Level.Verbose, "Base type for " + classEntity.Name + " conforms " + classEntity.ConformsTo);
// Retrieve protocols
if (!String.IsNullOrEmpty(classEntity.ConformsTo))
{
String[] parts = classEntity.ConformsTo.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries);
classEntity.Protocols = new List <ProtocolEntity> ();
foreach (var p in parts)
{
ProtocolEntity protocolEntity = this.FindAndLoad <ProtocolEntity>(baseFolder, entities, FrameworkEntityType.P, p);
if (protocolEntity == null)
{
continue;
}
classEntity.Protocols.Add(protocolEntity);
}
}
// Retrieve extended class
ClassEntity additionForEntity = this.FindAndLoad <ClassEntity>(baseFolder, entities, FrameworkEntityType.C, classEntity.AdditionFor);
this.Log(Level.Verbose, "Addition type for " + classEntity.Name + " is " + additionForEntity);
if (additionForEntity != null)
{
this.LoadClassDependencies(baseFolder, entities, additionForEntity);
classEntity.ExtendedClass = additionForEntity;
}
}
/// <summary>
/// Generates the specified entity.
/// </summary>
/// <param name = "entity">The entity.</param>
public override void Generate(BaseEntity entity)
{
ProtocolEntity protocolEntity = (ProtocolEntity)entity;
bool addition = !String.IsNullOrEmpty(protocolEntity.AdditionFor);
String name = protocolEntity.Name.Split('.') [0];
// Append License
this.Writer.WriteLineFormat(0, License);
// Append usings
this.AppendStandardNamespaces();
// Append namespace starter
this.Writer.WriteLineFormat(0, "namespace Monobjc.{0}", protocolEntity.Namespace);
this.Writer.WriteLineFormat(0, "{{");
// Append static condition if needed
this.AppendStartCondition(protocolEntity);
// Append class starter
if (!addition)
{
this.Writer.WriteLineFormat(1, "[ObjectiveCProtocol(\"{0}\")]", name);
#if GENERATED_ATTRIBUTE
this.Writer.WriteLineFormat(1, "[GeneratedCodeAttribute(\"{0}\", \"{1}\")]", GenerationHelper.ToolName, GenerationHelper.ToolVersion);
#endif
}
if (addition)
{
this.Writer.WriteLineFormat(1, "public partial interface I{0}", name);
}
else if (String.IsNullOrEmpty(protocolEntity.BaseType))
{
this.Writer.WriteLineFormat(1, "public partial interface I{0} : {1}", name, "IManagedWrapper");
}
else
{
this.Writer.WriteLineFormat(1, "public partial interface I{0} : I{1}", name, protocolEntity.BaseType);
}
this.Writer.WriteLineFormat(1, "{{");
// Append methods
foreach (MethodEntity methodEntity in protocolEntity.Methods.Where(e => e.Generate))
{
if (methodEntity.Static)
{
continue;
}
this.MethodGenerator.Generate(protocolEntity, methodEntity, false, false);
this.Writer.WriteLine();
}
// Append properties
foreach (PropertyEntity propertyEntity in protocolEntity.Properties.Where(e => e.Generate))
{
if (propertyEntity.Static)
{
continue;
}
this.PropertyGenerator.Generate(protocolEntity, propertyEntity, false);
this.Writer.WriteLine();
}
// Append class ender
this.Writer.WriteLineFormat(1, "}}");
// Append static condition if needed
this.AppendEndCondition(protocolEntity);
// Append namespace ender
this.Writer.WriteLineFormat(0, "}}");
// Update statistics
this.Statistics.Protocols++;
}
/// <summary>
/// Executes the task.
/// </summary>
protected override void ExecuteTask()
{
String baseFolder = this.CreateBaseDir();
DocSet docSet = this.CreateDocSet();
IEnumerable <Framework> frameworks = this.CreateFrameworks(docSet);
IList <FrameworkEntity> entities = frameworks.SelectMany(f => f.GetEntities()).ToList();
String mixedTypesFile = this.MixedTypesFile.ToString();
Dictionary <String, String> mixedTypesTable = new Dictionary <String, String> ();
this.LoadMixedTypes(mixedTypesFile, mixedTypesTable);
foreach (var e in entities)
{
String sourcePath = e.GetPath(baseFolder, DocumentType.Model);
if (sourcePath == null || !File.Exists(sourcePath))
{
continue;
}
if (sourcePath.IsOlderThan(mixedTypesFile))
{
continue;
}
this.Log(Level.Verbose, String.Format("Scanning '{0}' for mixed types...", e.name));
switch (e.type)
{
case FrameworkEntityType.T:
{
TypedEntity entity = BaseEntity.LoadFrom <TypedEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.C:
{
ClassEntity entity = BaseEntity.LoadFrom <ClassEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.P:
{
ProtocolEntity entity = BaseEntity.LoadFrom <ProtocolEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.S:
{
StructureEntity entity = BaseEntity.LoadFrom <StructureEntity> (sourcePath);
if (entity.Generate)
{
this.AddMixedType(mixedTypesTable, entity);
}
}
break;
case FrameworkEntityType.E:
{
EnumerationEntity entity = BaseEntity.LoadFrom <EnumerationEntity> (sourcePath);
if (entity.Generate)
{
this.AddMixedType(mixedTypesTable, entity);
}
}
break;
default:
throw new NotSupportedException("Entity type not support: " + e.type);
}
}
this.SaveMixedTypes(mixedTypesFile, mixedTypesTable);
}
private void LoadProtocolDependencies(String baseFolder, IList <FrameworkEntity> entities, ProtocolEntity protocolEntity)
{
if (protocolEntity == null)
{
return;
}
this.Log(Level.Verbose, "Loading protocol dependencies for " + protocolEntity.Name);
this.LoadClassDependencies(baseFolder, entities, protocolEntity);
// Retrieve delegator class
ClassEntity delegateForEntity = this.FindAndLoad <ClassEntity>(baseFolder, entities, FrameworkEntityType.C, protocolEntity.DelegateFor);
if (delegateForEntity != null)
{
this.LoadClassDependencies(baseFolder, entities, delegateForEntity);
protocolEntity.DelegatorEntity = delegateForEntity;
}
}
private Dictionary <String, String> LoadMixedTypes(String baseFolder, IList <FrameworkEntity> entities)
{
this.Log(Level.Info, "Loading mixed types...");
Dictionary <String, String> table = new Dictionary <String, String> ();
foreach (var e in entities)
{
String sourcePath = e.GetPath(baseFolder, DocumentType.Model);
if (sourcePath == null || !File.Exists(sourcePath))
{
continue;
}
this.Log(Level.Verbose, String.Format("Scanning '{0}' for mixed types...", e.name));
switch (e.type)
{
case FrameworkEntityType.T:
{
TypedEntity entity = BaseEntity.LoadFrom <TypedEntity> (sourcePath);
this.AddMixedType(table, entity.Name, entity.MixedType);
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
this.AddMixedType(table, enumerationEntity.Name, enumerationEntity.MixedType);
}
}
break;
case FrameworkEntityType.C:
{
ClassEntity entity = BaseEntity.LoadFrom <ClassEntity> (sourcePath);
this.AddMixedType(table, entity.Name, entity.MixedType);
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
this.AddMixedType(table, enumerationEntity.Name, enumerationEntity.MixedType);
}
}
break;
case FrameworkEntityType.P:
{
ProtocolEntity entity = BaseEntity.LoadFrom <ProtocolEntity> (sourcePath);
this.AddMixedType(table, entity.Name, entity.MixedType);
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
this.AddMixedType(table, enumerationEntity.Name, enumerationEntity.MixedType);
}
}
break;
case FrameworkEntityType.S:
{
StructureEntity entity = BaseEntity.LoadFrom <StructureEntity> (sourcePath);
this.AddMixedType(table, entity.Name, entity.MixedType);
}
break;
case FrameworkEntityType.E:
{
EnumerationEntity entity = BaseEntity.LoadFrom <EnumerationEntity> (sourcePath);
this.AddMixedType(table, entity.Name, entity.MixedType);
}
break;
default:
throw new NotSupportedException("Entity type not support: " + e.type);
}
}
this.Log(Level.Info, "Loaded {0} mixed types", table.Count);
return(table);
}
/// <summary>
/// Generates the specified entity.
/// </summary>
/// <param name = "entity">The entity.</param>
public override void Generate(BaseEntity entity)
{
ProtocolEntity protocolEntity = (ProtocolEntity)entity;
ClassEntity delegatorEntity = protocolEntity.DelegatorEntity;
//String property = protocolEntity.DelegateProperty;
PropertyEntity propertyEntity = delegatorEntity.GetProperties(true, false).FirstOrDefault(p => p.Name == protocolEntity.DelegateProperty);
// Gather methods for delegate
IEnumerable <MethodEntity> methods = protocolEntity.Methods.Where(e => e.Generate);
methods = methods.Concat(delegatorEntity.DelegateMethods.Where(e => e.Generate));
// Append License)
this.Writer.WriteLineFormat(0, License);
// Append usings
this.AppendStandardNamespaces();
// Append namespace starter
this.Writer.WriteLineFormat(0, "namespace Monobjc.{0}", protocolEntity.Namespace);
this.Writer.WriteLineFormat(0, "{{");
// Append static condition if needed
this.AppendStartCondition(delegatorEntity);
// Append class starter
this.Writer.WriteLineFormat(1, "public partial class {0}", delegatorEntity.Name, protocolEntity.Namespace);
this.Writer.WriteLineFormat(1, "{{");
// Emit delegate handlers
foreach (MethodEntity methodEntity in methods)
{
// Append static condition if needed
this.AppendStartCondition(methodEntity);
this.AppendDocumentation(2, methodEntity);
StringBuilder signature = new StringBuilder();
signature.AppendFormat("public delegate {0} {1}EventHandler(", methodEntity.ReturnType, methodEntity.Name);
List <String> parameters = new List <String> ();
foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(e => e.Generate))
{
parameters.Add(GetTypeSignature(methodParameterEntity));
}
signature.Append(String.Join(", ", parameters.ToArray()));
signature.Append(");");
this.Writer.WriteLineFormat(2, signature.ToString());
// Append static condition if needed
this.AppendEndCondition(methodEntity);
this.Writer.WriteLine();
}
//if (property != null)
if (propertyEntity != null)
{
// Append static condition if needed
this.AppendStartCondition(propertyEntity);
// Emit the delegate assignment
this.Writer.WriteLineFormat(2, "/// <summary>");
//this.Writer.WriteLineFormat(2, "/// Set the {0} property of a <see cref=\"{1}\"/> instance.", property, delegatorEntity.Name);
this.Writer.WriteLineFormat(2, "/// Set the {0} property of a <see cref=\"{1}\"/> instance.", propertyEntity.Name, delegatorEntity.Name);
this.Writer.WriteLineFormat(2, "/// </summary>");
this.Writer.WriteLineFormat(2, "/// <param name=\"assignment\">The assignment of delegation methods.</param>");
//this.Writer.WriteLineFormat(2, "public void Set{0}(Action<{1}EventDispatcher> assignment)", property, protocolEntity.Name);
this.Writer.WriteLineFormat(2, "public void Set{0}(Action<{1}EventDispatcher> assignment)", propertyEntity.Name, protocolEntity.Name);
this.Writer.WriteLineFormat(2, "{{");
//this.Writer.WriteLineFormat(3, "{0}EventDispatcher @delegate = this.{1}.SafeCastAs<{0}EventDispatcher>();", protocolEntity.Name, property);
this.Writer.WriteLineFormat(3, "{0}EventDispatcher @delegate = this.{1}.SafeCastAs<{0}EventDispatcher>();", protocolEntity.Name, propertyEntity.Name);
this.Writer.WriteLineFormat(3, "if (@delegate != null)");
this.Writer.WriteLineFormat(3, "{{");
this.Writer.WriteLineFormat(4, "@delegate.Release();");
//this.Writer.WriteLineFormat(4, "this.{0} = null;", property);
this.Writer.WriteLineFormat(4, "this.{0} = null;", propertyEntity.Name);
this.Writer.WriteLineFormat(3, "}}");
this.Writer.WriteLineFormat(3, "if (assignment != null)");
this.Writer.WriteLineFormat(3, "{{");
this.Writer.WriteLineFormat(4, "@delegate = new {0}EventDispatcher();", protocolEntity.Name);
this.Writer.WriteLineFormat(4, "assignment(@delegate);");
//this.Writer.WriteLineFormat(4, "this.{0} = @delegate;", property);
this.Writer.WriteLineFormat(4, "this.{0} = @delegate;", propertyEntity.Name);
this.Writer.WriteLineFormat(3, "}}");
this.Writer.WriteLineFormat(2, "}}");
this.Writer.WriteLine();
// Append static condition if needed
this.AppendEndCondition(propertyEntity);
}
// Emit the inner class
this.Writer.WriteLineFormat(2, "[ObjectiveCClass]");
#if GENERATED_ATTRIBUTE
this.Writer.WriteLineFormat(2, "[GeneratedCodeAttribute(\"{0}\", \"{1}\")]", GenerationHelper.ToolName, GenerationHelper.ToolVersion);
#endif
// TODO: Set correct super-class
this.Writer.WriteLineFormat(2, "public class {0}EventDispatcher : NSObject", protocolEntity.Name, protocolEntity.Namespace);
this.Writer.WriteLineFormat(2, "{{");
// Add constant for class access
this.Writer.WriteLineFormat(3, "/// <summary>");
this.Writer.WriteLineFormat(3, "/// Static field for a quick access to the {0}EventDispatcher class.", protocolEntity.Name);
this.Writer.WriteLineFormat(3, "/// </summary>");
this.Writer.WriteLineFormat(3, "public static readonly Class {0}EventDispatcherClass = Class.Get(typeof ({0}EventDispatcher));", protocolEntity.Name);
this.Writer.WriteLine();
// Add default constructor
this.Writer.WriteLineFormat(3, "/// <summary>");
this.Writer.WriteLineFormat(3, "/// Initializes a new instance of the <see cref=\"{0}EventDispatcher\"/> class.", protocolEntity.Name);
this.Writer.WriteLineFormat(3, "/// </summary>");
this.Writer.WriteLineFormat(3, "public {0}EventDispatcher() {{}}", protocolEntity.Name);
this.Writer.WriteLine();
// Add constructor with pointer parameter
this.Writer.WriteLineFormat(3, "/// <summary>");
this.Writer.WriteLineFormat(3, "/// Initializes a new instance of the <see cref=\"{0}EventDispatcher\"/> class.", protocolEntity.Name);
this.Writer.WriteLineFormat(3, "/// </summary>");
this.Writer.WriteLineFormat(3, "/// <param name=\"value\">The native pointer.</param>");
this.Writer.WriteLineFormat(3, "public {0}EventDispatcher(IntPtr value)", protocolEntity.Name);
this.Writer.WriteLineFormat(4, ": base(value) {{}}");
this.Writer.WriteLine();
// Emit the respondsTo method
this.Writer.WriteLineFormat(3, "[ObjectiveCMessage(\"respondsToSelector:\")]");
this.Writer.WriteLineFormat(3, "public override bool RespondsToSelector(IntPtr aSelector)");
this.Writer.WriteLineFormat(3, "{{");
this.Writer.WriteLineFormat(4, "String message = ObjectiveCRuntime.Selector(aSelector);");
this.Writer.WriteLineFormat(4, "switch (message)");
this.Writer.WriteLineFormat(4, "{{");
foreach (MethodEntity methodEntity in methods)
{
// Append static condition if needed
this.AppendStartCondition(methodEntity);
this.Writer.WriteLineFormat(5, "case \"{0}\":", methodEntity.Selector);
this.Writer.WriteLineFormat(6, "return (this.{0} != null);", methodEntity.Name);
// Append static condition if needed);
this.AppendEndCondition(methodEntity);
}
this.Writer.WriteLineFormat(5, "default:");
this.Writer.WriteLineFormat(6, "return this.SendMessageSuper<bool>({0}EventDispatcherClass, \"respondsToSelector:\", aSelector);", protocolEntity.Name);
this.Writer.WriteLineFormat(4, "}}");
this.Writer.WriteLineFormat(3, "}}");
this.Writer.WriteLine();
// Emit the dealloc method
this.Writer.WriteLineFormat(3, "[ObjectiveCMessage(\"dealloc\")]");
this.Writer.WriteLineFormat(3, "public override void Dealloc()");
this.Writer.WriteLineFormat(3, "{{");
foreach (MethodEntity methodEntity in methods)
{
// Append static condition if needed
this.AppendStartCondition(methodEntity);
this.Writer.WriteLineFormat(4, "if (this.{0} != null)", methodEntity.Name);
this.Writer.WriteLineFormat(4, "{{");
this.Writer.WriteLineFormat(5, "foreach(Delegate handler in this.{0}.GetInvocationList())", methodEntity.Name);
this.Writer.WriteLineFormat(5, "{{");
this.Writer.WriteLineFormat(6, "this.{0} -= ({0}EventHandler) handler;", methodEntity.Name);
this.Writer.WriteLineFormat(5, "}}");
this.Writer.WriteLineFormat(4, "}}");
// Append static condition if needed);
this.AppendEndCondition(methodEntity);
}
this.Writer.WriteLineFormat(4, "this.SendMessageSuper({0}EventDispatcherClass, \"dealloc\");", protocolEntity.Name);
this.Writer.WriteLineFormat(3, "}}");
this.Writer.WriteLine();
// Emit the event handlers
foreach (MethodEntity methodEntity in methods)
{
// Append static condition if needed
this.AppendStartCondition(methodEntity);
this.AppendDocumentation(3, methodEntity);
this.Writer.WriteLineFormat(3, "public event {0}EventHandler {0};", methodEntity.Name);
// Append static condition if needed);
this.AppendEndCondition(methodEntity);
this.Writer.WriteLine();
}
// Emit the handler methods
foreach (MethodEntity methodEntity in methods)
{
bool hasReturnType = !String.Equals(methodEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase);
// Append static condition if needed
this.AppendStartCondition(methodEntity);
this.AppendDocumentation(3, methodEntity);
StringBuilder signature = new StringBuilder();
this.Writer.WriteLineFormat(3, "[ObjectiveCMessage(\"{0}\")]", methodEntity.Selector);
signature.AppendFormat("public {0} {1}Message(", methodEntity.ReturnType, methodEntity.Name);
List <String> parameters = new List <String> ();
foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate))
{
parameters.Add(GetTypeSignature(methodParameterEntity));
}
signature.Append(String.Join(", ", parameters.ToArray()));
signature.Append(")");
this.Writer.WriteLineFormat(3, signature.ToString());
this.Writer.WriteLineFormat(3, "{{");
this.Writer.WriteLineFormat(4, "if (this.{0} == null)", methodEntity.Name);
this.Writer.WriteLineFormat(4, "{{");
this.Writer.WriteLineFormat(5, "throw new NotSupportedException(\"The delegate does not respond to '{0}' message.\");", methodEntity.Selector);
this.Writer.WriteLineFormat(4, "}}");
StringBuilder invocation = new StringBuilder();
if (hasReturnType)
{
invocation.Append("return ");
}
invocation.AppendFormat("this.{0}(", methodEntity.Name);
parameters = new List <string> ();
foreach (MethodParameterEntity p in methodEntity.Parameters.Where(p => p.Generate))
{
parameters.Add(GetInvocationParameter(p));
}
invocation.Append(String.Join(", ", parameters.ToArray()));
invocation.Append(");");
this.Writer.WriteLineFormat(4, invocation.ToString());
this.Writer.WriteLineFormat(3, "}}");
// Append static condition if needed);
this.AppendEndCondition(methodEntity);
this.Writer.WriteLine();
}
// Append inner-class ender
this.Writer.WriteLineFormat(2, "}}");
// Append class ender
this.Writer.WriteLineFormat(1, "}}");
// Append static condition if needed
this.AppendEndCondition(delegatorEntity);
// Append namespace ender
this.Writer.WriteLineFormat(0, "}}");
}
public ActionResult SaveForm(string keyValue, ProtocolEntity entity)
{
protocolbll.SaveForm(keyValue, entity);
return(Success("操作成功。"));
}
