public IEnumerable <TEntity> ExecuteMany <TEntity>(string name,
IDictionary <string, object> parameters = null) where TEntity : class
{
return(Load <TEntity, IEnumerable <TEntity> >(Command.Create(
StatementWriter.CreateStoredProcedure(name, parameters,
Statement.ResultType.Multiple), _profiler)));
}
public DataTable ExecuteDataTable(string tableName, string name,
IDictionary <string, object> parameters = null)
{
return(Command.Create(StatementWriter.CreateStoredProcedure(name,
parameters, Statement.ResultType.Multiple), _profiler)
.ExecuteDataTable(tableName, _connectionManager));
}
public TEntity ExecuteSingle <TEntity>(string commandText,
IDictionary <string, object> parameters = null) where TEntity : class
{
return(ExecuteBatches(commandText, parameters, x =>
Load <TEntity, TEntity>(Command.Create(StatementWriter.CreateStatement(x,
parameters, Statement.ResultType.Single), _profiler))));
}
public TEntity ExecuteSingleOrNone <TEntity>(string name,
IDictionary <string, object> parameters = null) where TEntity : class
{
return(Load <TEntity, TEntity>(Command.Create(StatementWriter
.CreateStoredProcedure(name, parameters,
Statement.ResultType.SingleOrNone), _profiler)));
}
public T ExecuteScalar <T>(string commandText, IDictionary <string, object> parameters = null)
{
return(ExecuteBatches(commandText, parameters, x =>
Command.Create(StatementWriter.CreateStatement(x,
parameters, Statement.ResultType.Scalar), _profiler)
.ExecuteScalar <T>(_connectionManager)));
}
public DataTable ExecuteDataTable(string tableName, string commandText,
IDictionary <string, object> parameters = null)
{
return(ExecuteBatches(commandText, parameters, x =>
Command.Create(StatementWriter.CreateStatement(x, parameters,
Statement.ResultType.Multiple), _profiler)
.ExecuteDataTable(tableName, _connectionManager)));
}
/// <summary>
/// Serializes the <paramref name="expression" />.
/// </summary>
/// <param name="expression">The expression that should be serialized.</param>
public string Serialize(Expression expression)
{
_writer.Clear();
var statementWriter = new StatementWriter(_writer);
statementWriter.Visit(expression);
return _writer.ToString();
}
/// <summary>
/// Serializes the <paramref name="statement" />.
/// </summary>
/// <param name="statement">The statement that should be serialized.</param>
public string Serialize(Statement statement)
{
_writer.Clear();
var statementWriter = new StatementWriter(_writer);
statementWriter.Visit(statement);
return _writer.ToString();
}
public int Execute(string name, IDictionary <string, object> parameters = null)
{
return(Command.Create(StatementWriter.CreateStoredProcedure(name,
parameters, Statement.ResultType.None), _profiler)
.ExecuteNonQuery(_connectionManager));
}
private int ExecuteNonQuery(string commandText, IDictionary <string, object> parameters = null)
{
return(Command.Create(StatementWriter.CreateStatement(commandText,
parameters, Statement.ResultType.None), _profiler)
.ExecuteNonQuery(_connectionManager));
}
public void WriteStatement(IStatement state)
{
StatementWriter.WriteStatement(this, state);
}
/// <summary>
/// Serializes the <paramref name="metadata" />.
/// </summary>
/// <param name="metadata">The metadata of the component that should be serialized.</param>
private string SerializeRecursive(ComponentMetadata metadata)
{
_writer.AppendLine("public class {0} : Component", metadata.Name ?? "C");
_writer.AppendBlockStatement(() =>
{
var statementWriter = new StatementWriter(_writer, metadata);
foreach (var field in metadata.Fields)
_writer.AppendLine("public {0} {1};", field.Type.FullName, field.Name);
foreach (var port in metadata.RequiredPorts)
{
_writer.AppendLine("public extern {0} {1}({2});", ReturnType(port.MethodInfo.ReturnType), port.Name,
String.Join(", ", port.MethodInfo.GetParameters().Select(Parameter)));
}
foreach (var port in metadata.ProvidedPorts)
{
_writer.AppendLine("public {0} {1}({2})", ReturnType(port.MethodInfo.ReturnType), port.Name,
String.Join(", ", port.MethodInfo.GetParameters().Select(Parameter)));
statementWriter.Visit(port.MethodBody);
}
_writer.AppendLine("public override void Update()");
statementWriter.Visit(metadata.StepMethod.MethodBody);
foreach (var subcomponent in metadata.Subcomponents)
{
SerializeRecursive(subcomponent);
_writer.AppendLine("public {0} _{0} = new {0}();", subcomponent.Name);
}
_writer.AppendLine("public {0}()", metadata.Name ?? "C");
_writer.AppendBlockStatement(() =>
{
foreach (var binding in metadata.Bindings)
_writer.AppendLine("Bind(RequiredPorts.{0} = ProvidedPorts.{1});", binding.RequiredPort.Name, binding.ProvidedPort.Name);
foreach (var field in metadata.Fields)
{
string values = null;
if (field.Type == typeof(int))
values = String.Join(", ", field.InitialValues);
if (field.Type == typeof(bool))
values = String.Join(", ", field.InitialValues.Select(v => v.ToString().ToLower()));
if (field.Type == typeof(double))
values = String.Join(", ", field.InitialValues.Select(v => ((double)v).ToString(CultureInfo.InvariantCulture)));
if (field.Type.IsEnum)
values = String.Join(", ", field.InitialValues.Select(v =>
String.Format("{0}.{1}", field.Type.Name, Enum.GetValues(field.Type).Cast<object>().First())));
_writer.AppendLine("SetInitialValues({0}, {1});", field.Name, values);
}
});
foreach (var enumeration in statementWriter.Enums.Union(metadata.Fields.Where(f => f.Type.IsEnum).Select(f => f.Type)))
{
var values = String.Join(", ", Enum.GetValues(enumeration).Cast<object>().Select(v => v.ToString()));
_writer.AppendLine("public enum {0} {{ {1} }}", enumeration.Name, values);
}
});
return _writer.ToString();
}
