private static void ScaffoldMappings(EntityFrameworkCoreProject project)
{
var projectSelection = project.GlobalSelection();
if (!projectSelection.Settings.UseDataAnnotations)
{
foreach (var table in project.Database.Tables)
{
if (project.Database.HasDefaultSchema(table))
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(), projectSelection.Settings.ForceOverwrite, project.GetEntityConfigurationClassDefinition(table));
}
else
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(table.Schema), projectSelection.Settings.ForceOverwrite, project.GetEntityConfigurationClassDefinition(table));
}
}
foreach (var view in project.Database.Views)
{
if (project.Database.HasDefaultSchema(view))
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(), projectSelection.Settings.ForceOverwrite, project.GetEntityTypeConfigurationClassDefinition(view));
}
else
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(view.Schema), projectSelection.Settings.ForceOverwrite, project.GetEntityTypeConfigurationClassDefinition(view));
}
}
}
}
public override void BuildOutput(CSharpCodeBuilder b)
{
var securityInfo = Model.SecurityInfo;
string namespaceName = WriteNamespaces(b);
b.Line();
using (b.Block($"namespace {namespaceName}.Api"))
{
WriteControllerRouteAttribute(b);
b.Line($"{securityInfo.ClassAnnotation}");
b.Line("[ServiceFilter(typeof(IApiActionFilter))]");
b.Line($"public partial class {Model.ApiControllerClassName} ");
b.Line($" : BaseApiController<{Model.BaseViewModel.FullyQualifiedName}, {Model.DtoName}, {DbContext.Type.FullyQualifiedName}>");
// b.Block() has no contents here because we put the base class on a separate line to avoid really long lines.
b.Line("{");
using (b.Indented())
{
WriteClassContents(b, securityInfo);
}
b.Line("}");
}
}
public void CreateCodeBuilder_PassesCodeGeneratorThroughDecorateMethodOnHost()
{
// Arrange
var mockHost = new Mock <RazorEngineHost>(new CSharpRazorCodeLanguage())
{
CallBase = true
};
var codeBuilderContext = new CodeBuilderContext(
mockHost.Object,
"different-class",
"different-ns",
string.Empty,
shouldGenerateLinePragmas: true);
var expected = new CSharpCodeBuilder(codeBuilderContext);
mockHost.Setup(h => h.DecorateCodeBuilder(It.IsAny <CSharpCodeBuilder>(), codeBuilderContext))
.Returns(expected);
var engine = new RazorTemplateEngine(mockHost.Object);
// Act
var actual = engine.CreateCodeBuilder(codeBuilderContext);
// Assert
Assert.Equal(expected, actual);
}
public override void BuildOutput(CSharpCodeBuilder b)
{
var namespaces = new List <string>
{
"IntelliTect.Coalesce",
"IntelliTect.Coalesce.Mapping",
"IntelliTect.Coalesce.Models",
"Newtonsoft.Json",
"System",
"System.Linq",
"System.Linq.Dynamic.Core",
"System.Collections.Generic",
"System.Security.Claims"
};
foreach (var ns in namespaces.OrderBy(n => n))
{
b.Line($"using {ns};");
}
string namespaceName = Namespace;
if (!string.IsNullOrWhiteSpace(AreaName))
{
namespaceName += "." + AreaName;
}
namespaceName += ".Models";
b.Line();
using (b.Block($"namespace {namespaceName}"))
{
WriteDtoClass(b, namespaceName);
}
}
public void TestCSharpInterfaceGeneration()
{
// Arrange
var definition = new CSharpInterfaceDefinition
{
Namespace = "ContactManager",
Name = "IPerson",
Namespaces = new List <string>
{
"System",
"System.ComponentModel"
}
};
definition.Properties.Add(new PropertyDefinition("Int32?", "ID"));
definition.Properties.Add(new PropertyDefinition("String", "FirstName"));
definition.Properties.Add(new PropertyDefinition("String", "MiddleName"));
definition.Properties.Add(new PropertyDefinition("String", "LastName"));
definition.Properties.Add(new PropertyDefinition("String", "FullName")
{
IsReadOnly = true
});
definition.Properties.Add(new PropertyDefinition("String", "Gender"));
definition.Properties.Add(new PropertyDefinition("DateTime?", "BirthDate"));
definition.Properties.Add(new PropertyDefinition("Int32", "Age")
{
IsReadOnly = true
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void DecorateCodeBuilder_DesignTimeRazorPathNormalizer_NormalizesChunkInheritanceUtilityPaths(
string rootPrefix)
{
// Arrange
var rootedAppPath = $"{rootPrefix}SomeComputer/Location/Project/";
var rootedFilePath = $"{rootPrefix}SomeComputer/Location/Project/src/file.cshtml";
var host = new MvcRazorHost(
codeTreeCache: null,
pathNormalizer: new DesignTimeRazorPathNormalizer(rootedAppPath));
var chunkInheritanceUtility = new PathValidatingChunkInheritanceUtility(host);
var codeBuilderContext = new CodeBuilderContext(
new CodeGeneratorContext(
host,
host.DefaultClassName,
host.DefaultNamespace,
rootedFilePath,
shouldGenerateLinePragmas: true),
new ParserErrorSink());
var codeBuilder = new CSharpCodeBuilder(codeBuilderContext);
host.ChunkInheritanceUtility = chunkInheritanceUtility;
// Act
host.DecorateCodeBuilder(codeBuilder, codeBuilderContext);
// Assert
Assert.Equal("src/file.cshtml", chunkInheritanceUtility.InheritedCodeTreePagePath, StringComparer.Ordinal);
}
public static EntityFrameworkCoreProject ScaffoldValueConversion(this EntityFrameworkCoreProject project)
{
var boolToStringConverters = new CSharpClassDefinition
{
Namespaces =
{
"Microsoft.EntityFrameworkCore.Storage.ValueConversion"
},
Namespace = "ValueConversion",
AccessModifier = AccessModifier.Public,
IsStatic = true,
Name = "BoolToStringConverters",
Fields =
{
new FieldDefinition
{
AccessModifier = AccessModifier.Private,
IsStatic = true,
IsReadOnly = true,
Type = "BoolToStringConverter",
Name = "bYN",
Value = "new BoolToStringConverter(\"N\", \"Y\")"
}
}
};
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerDirectory("ValueConversion"), true, boolToStringConverters);
return(project);
}
private static void ScaffoldDataRepositories(EntityFrameworkCoreProject project)
{
if (!string.IsNullOrEmpty(project.Settings.ConcurrencyToken))
{
project.UpdateExclusions.Add(project.Settings.ConcurrencyToken);
}
ScaffoldRepositoryInterface(project);
ScaffoldBaseRepositoryClassDefinition(project);
ScaffoldRepositoryExtensionsClassDefinition(project);
foreach (var projectFeature in project.Features)
{
var repositoryClassDefinition = projectFeature.GetRepositoryClassDefinition();
var interfaceDef = repositoryClassDefinition.RefactInterface();
interfaceDef.Implements.Add("IRepository");
interfaceDef.Namespace = project.GetDataLayerContractsNamespace();
ScaffoldDataLayerContract(project, interfaceDef);
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerRepositoriesDirectory(), project.Settings.ForceOverwrite, repositoryClassDefinition);
}
}
public void TestCSharpGenericClassGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.Collections.Generic"
},
Namespace = "Mapping",
IsPartial = true,
Name = "GenericRepository",
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TEntity",
Constraint = "TEntity : class, new()"
}
},
Documentation = new Documentation
{
Summary = "Contains repository methos for entity",
Remarks = "This is an implementation according to design patterns."
}
};
definition.Methods.Add(new MethodDefinition("Int32", "CommitChanges"));
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
private void WriteClassContents(CSharpCodeBuilder b)
{
b.Line($"protected {Model.FullyQualifiedName} Service {{ get; }}");
b.Line();
using (b.Block($"public {Model.ApiControllerClassName}({Model.FullyQualifiedName} service)"))
{
b.Line("Service = service;");
}
foreach (var method in Model.ClientMethods)
{
var returnType = method.ApiActionReturnTypeDeclaration;
if (method.IsAwaitable)
{
returnType = $"async Task<{returnType}>";
}
b.DocComment($"Method: {method.Name}");
b.Line($"[{method.ApiActionHttpMethodAnnotation}(\"{method.Name}\")]");
b.Line($"{method.SecurityInfo.ExecuteAnnotation}");
using (b.Block($"{Model.ApiActionAccessModifier} virtual {returnType} {method.Name} ({method.CsParameters})"))
{
if (method.ResultType.HasClassViewModel ||
(method.ResultType.PureType.HasClassViewModel && method.ResultType.IsCollection))
{
b.Line("IncludeTree includeTree = null;");
}
WriteMethodInvocation(b, method, "Service");
WriteMethodResultProcessBlock(b, method);
}
}
}
public void ScaffoldingClassWithOnlyFields()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "Foo",
Fields =
{
new FieldDefinition(AccessModifier.Public, "string", "Bar")
{
IsReadOnly = true,
Value = "\"ABC\""
}
},
Constructors =
{
new ClassConstructorDefinition()
}
};
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public static EntityFrameworkCoreProject ScaffoldEntityLayer(this EntityFrameworkCoreProject project)
{
ScaffoldEntityInterface(project);
foreach (var table in project.Database.Tables)
{
var classDefinition = project.GetEntityClassDefinition(table);
if (project.Settings.UseDataAnnotations)
{
classDefinition.AddDataAnnotations(table);
}
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), project.Settings.ForceOverwrite, classDefinition);
}
foreach (var view in project.Database.Views)
{
var classDefinition = project.GetEntityClassDefinition(view);
if (project.Settings.UseDataAnnotations)
{
classDefinition.AddDataAnnotations(view, project);
}
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), project.Settings.ForceOverwrite, classDefinition);
}
return(project);
}
private static void ScaffoldDbContext(EntityFrameworkCoreProject project)
{
foreach (var projectFeature in project.Features)
{
CSharpCodeBuilder
.CreateFiles(project.OutputDirectory, project.GetDataLayerDirectory(), project.Settings.ForceOverwrite, projectFeature.GetDbContextClassDefinition());
}
}
private static void ScaffoldEntityInterface(EntityFrameworkCoreProject project)
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), project.Settings.ForceOverwrite, project.GetEntityInterfaceDefinition());
if (project.Settings.AuditEntity != null)
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), project.Settings.ForceOverwrite, project.GetAuditEntityInterfaceDefinition());
}
}
public void TestCsharpRepositoryClassGeneration()
{
// Arrange
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespaces.Add("System.Collections.Generic");
definition.Namespace = "Repositories";
definition.Name = "DboRepository";
definition.Implements.Add("IRepository");
definition.Fields.Add(new FieldDefinition(AccessModifier.Private, "DbContext", "m_dbContext"));
definition.Constructors.Add(new ClassConstructorDefinition());
definition.AddReadOnlyProperty("DbContext", "DbContext", new CodeLine("return m_dbContext;"));
definition.Properties.Add(new PropertyDefinition("IUserInfo", "UserInfo"));
definition.Methods.Add(new MethodDefinition("Task<Int32>", "CommitChangesAsync")
{
IsAsync = true,
Lines = new List <ILine>
{
new CommentLine("Save changes in async way"),
new CodeLine("return await DbContext.SaveChangesAsync();")
}
});
definition.Methods.Add(new MethodDefinition("IEnumerable<TEntity>", "GetAll")
{
Lines = new List <ILine>
{
new TodoLine("Check generic cast"),
new CodeLine("return DbContext.Set<TEntity>();")
}
});
definition.Methods.Add(new MethodDefinition("void", "Add", new ParameterDefinition("TEntity", "entity"))
{
Lines = new List <ILine>
{
new CommentLine("Check entry state"),
new CodeLine("DbContext.Set<TEntity>().Add(entity);"),
new CodeLine(),
new TodoLine("Save changes in async way"),
new CodeLine("DbContext.SaveChanges();")
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
private static void ScaffoldMappingDependencies(EntityFrameworkCoreProject project)
{
if (!project.Settings.UseDataAnnotations)
{
CSharpCodeBuilder
.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(), project.Settings.ForceOverwrite, project.GetEntityMapperInterfaceDefinition(), project.GetEntityTypeConfigurationInterfaceDefinition());
CSharpCodeBuilder
.CreateFiles(project.OutputDirectory, project.GetDataLayerConfigurationsDirectory(), project.Settings.ForceOverwrite, project.GetEntityMapperClassDefinition(), project.GetDatabaseEntityMapperClassDefinition());
}
}
/// <summary>
/// For a method invocation controller action, writes the actual invocation of the method.
/// </summary>
/// <param name="b">The CodeBuilder to write to</param>
/// <param name="method">The method to be invoked</param>
/// <param name="owningMember">
/// The member on which to invoke the method.
/// This could be an variable holding an instance of a type, or a class reference if the method is static.
/// </param>
public void WriteMethodInvocation(CSharpCodeBuilder b, MethodViewModel method, string owningMember)
{
// Don't try to store the result in the variable if the method returns void.
if (!method.TaskUnwrappedReturnType.IsVoid)
{
b.Append($"var {MethodResultVar} = ");
}
var awaitSymbol = method.IsAwaitable ? "await " : "";
b.Line($"{awaitSymbol}{owningMember}.{method.Name}({method.CsArguments});");
}
public void ScaffoldingOrderClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System",
"System.ComponentModel.DataAnnotations",
"System.ComponentModel.DataAnnotations.Schema"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "Order"
};
definition.Attributes.Add(new MetadataAttribute("Table", "\"Orders\"")
{
Sets =
{
new MetadataAttributeSet("Schema", "\"dbo\"")
}
});
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("Int32?", "OrderID", attributes: new[]
{
new MetadataAttribute("Key"),
new MetadataAttribute("DatabaseGenerated", "DatabaseGeneratedOption.Identity")
})
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("DateTime?", "OrderDate", attributes: new[] { new MetadataAttribute("Column") })
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("String", "CustomerID", attributes: new[]
{
new MetadataAttribute("Column"),
new MetadataAttribute("StringLength", "5")
})
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("Int32?", "ShipperID", attributes: new[] { new MetadataAttribute("Column") })
);
definition.SimplifyDataTypes();
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
private static void ScaffoldEntityInterface(this DapperProject project)
{
var globalSelection = project.GlobalSelection();
var interfaceDefinition = new CSharpInterfaceDefinition
{
Namespace = project.GetEntityLayerNamespace(),
Name = "IEntity"
};
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), globalSelection.Settings.ForceOverwrite, interfaceDefinition);
}
/// <summary>
/// Writes the route attribute for an API controller.
/// If the API controller has routing disabled, nothing will be written.
/// </summary>
protected void WriteControllerRouteAttribute(CSharpCodeBuilder b)
{
if (Model.ApiRouted)
{
if (!string.IsNullOrWhiteSpace(AreaName))
{
b.Line($"[Route(\"{AreaName}/api/{Model.ApiRouteControllerPart}\")]");
}
else
{
b.Line($"[Route(\"api/{Model.ApiRouteControllerPart}\")]");
}
}
}
private static void ScaffoldDataContracts(EntityFrameworkCoreProject project)
{
foreach (var table in project.Database.Tables)
{
if (!project.Settings.EntitiesWithDataContracts.Contains(table.FullName))
{
continue;
}
var classDefinition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System"
},
Namespace = project.GetDataLayerDataContractsNamespace(),
Name = table.GetDataContractName()
};
foreach (var column in table.Columns)
{
classDefinition.Properties.Add(new PropertyDefinition(column.GetClrType(), column.GetPropertyName()));
}
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTableByFullName(foreignKey.References);
if (foreignTable == null)
{
continue;
}
var foreignKeyAlias = NamingConvention.GetCamelCase(foreignTable.GetEntityName());
foreach (var column in foreignTable?.GetColumnsWithOutPrimaryKey())
{
var target = string.Format("{0}{1}", foreignTable.GetEntityName(), column.GetPropertyName());
if (classDefinition.Properties.Where(item => item.Name == column.GetPropertyName()).Count() == 0)
{
classDefinition.Properties.Add(new PropertyDefinition(column.GetClrType(), target));
}
}
}
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerDataContractsDirectory(), project.Settings.ForceOverwrite, classDefinition);
}
}
public static EntityFrameworkCoreProject ScaffoldEntityLayer(this EntityFrameworkCoreProject project)
{
ScaffoldEntityInterface(project);
foreach (var table in project.Database.Tables)
{
var selection = project.GetSelection(table);
var definition = project.GetEntityClassDefinition(table);
if (selection.Settings.UseDataAnnotations)
{
definition.AddDataAnnotations(table, project);
}
if (project.Database.HasDefaultSchema(table))
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), selection.Settings.ForceOverwrite, definition);
}
else
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(table.Schema), selection.Settings.ForceOverwrite, definition);
}
}
foreach (var view in project.Database.Views)
{
var selection = project.GetSelection(view);
var definition = project.GetEntityClassDefinition(view);
if (selection.Settings.UseDataAnnotations)
{
definition.AddDataAnnotations(view, project);
}
if (project.Database.HasDefaultSchema(view))
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(), selection.Settings.ForceOverwrite, definition);
}
else
{
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetEntityLayerDirectory(view.Schema), selection.Settings.ForceOverwrite, definition);
}
}
return(project);
}
private static void ScaffoldDataContracts(EntityFrameworkCoreProject project)
{
foreach (var table in project.Database.Tables)
{
var selection = project.GetSelection(table);
if (!selection.Settings.EntitiesWithDataContracts)
{
continue;
}
var classDefinition = project.GetDataContractClassDefinition(table);
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerDataContractsDirectory(), selection.Settings.ForceOverwrite, classDefinition);
}
}
public void TestCSharpGenericInterfaceGeneration()
{
// Arrange
var definition = new CSharpInterfaceDefinition
{
Namespaces = new List <string>
{
"System",
"System.Threading.Tasks"
},
Namespace = "Contracts",
IsPartial = true,
Name = "IGenericRepository",
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TEntity",
Constraint = "TEntity : class, new()"
}
}
};
definition.Properties.Add(new PropertyDefinition("DbContext", "DbContext")
{
IsReadOnly = true
});
definition.Methods.Add(new MethodDefinition("Task<Int32>", "CommitChanges", new ParameterDefinition("int", "foo", "0")));
definition.Methods.Add(new MethodDefinition("Task<Int32>", "CommitChangesAsync"));
definition.Methods.Add(new MethodDefinition("void", "Audit")
{
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TEntity"
}
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public override void BuildOutput(CSharpCodeBuilder b)
{
ClassViewModel model = Model;
string namespaceName = WriteNamespaces(b);
b.Line();
using (b.Block($"namespace {namespaceName}.Api"))
{
WriteControllerRouteAttribute(b);
/* No controller-level security annotation is applied - all security for service controllers is on a per-action basis. */
b.Line("[ServiceFilter(typeof(IApiActionFilter))]");
using (b.Block($"public partial class {Model.ApiControllerClassName} : Controller"))
{
WriteClassContents(b);
}
}
}
public void ScaffoldingBaseRepositoryClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsPartial = true,
Name = "Repository",
Implements =
{
"IRepository"
},
Constructors =
{
new ClassConstructorDefinition(AccessModifier.Public, new ParameterDefinition("NorthwindDbContext", "dbContext"))
{
Lines =
{
new CodeLine("DbContext = dbContext;")
}
}
},
Properties =
{
CSharpClassDefinition.CreateReadonlyProperty("NorthwindDbContext", "DbContext", accessModifier: AccessModifier.Protected),
},
Methods =
{
new MethodDefinition(AccessModifier.Public, "", "Dispose")
{
Lines =
{
new TodoLine("Implement dispose for DbContext")
}
}
}
};
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public void TestCsharpClassWithMethodsGeneration()
{
// Arrange
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespace = "Operations";
definition.Name = "Helpers";
definition.Methods.Add(new MethodDefinition("void", "Foo", new ParameterDefinition("int", "foo", "0"), new ParameterDefinition("int", "bar", "1"))
{
IsAsync = true
});
definition.Methods.Add(new MethodDefinition("void", "Bar", new ParameterDefinition("int", "a")));
definition.Methods.Add(new MethodDefinition("int", "Zaz")
{
Lines = new List <ILine>
{
new CodeLine("return 0;")
}
});
definition.Methods.Add(new MethodDefinition("int", "Qux")
{
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "T",
Constraint = "T : class"
}
},
Lines = new List <ILine>
{
new CodeLine("return 0;")
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void TestCSharpClassWithIndexerGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.Collections.Generic"
},
Namespace = "Mapping",
Name = "DataSet"
};
definition.Indexers.Add(new IndexerDefinition
{
AccessModifier = AccessModifier.Public,
Type = "string",
Parameters = new List <ParameterDefinition>
{
new ParameterDefinition
{
Type = "int",
Name = "index"
}
},
GetBody = new List <ILine>
{
new CodeLine("return m_columns[index];")
},
SetBody = new List <ILine>
{
new CodeLine("m_columns = value;")
}
});
definition.AddPropertyWithField("List<string>", "Columns");
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void ScaffoldingProductViewModelClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System",
"System.ComponentModel"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsPartial = true,
Name = "Product",
Implements =
{
"INotifyPropertyChanged"
},
Events =
{
new EventDefinition("PropertyChangedEventHandler", "PropertyChanged")
{
AccessModifier = AccessModifier.Public
}
}
};
definition.AddViewModelProperty("int?", "ProductID");
definition.AddViewModelProperty("string", "ProductName");
definition.AddViewModelProperty("int?", "SupplierID");
definition.AddViewModelProperty("int?", "CategoryID");
definition.AddViewModelProperty("string", "QuantityPerUnit");
definition.AddViewModelProperty("decimal?", "UnitPrice");
definition.AddViewModelProperty("short?", "UnitsInStock");
definition.AddViewModelProperty("short?", "UnitsOnOrder");
definition.AddViewModelProperty("short?", "ReorderLevel");
definition.AddViewModelProperty("bool?", "Discontinued");
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public void ScaffoldingBaseRepositoryInterface()
{
// Arrange
var definition = new CSharpInterfaceDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "IRepository",
Implements =
{
"IDisposable"
}
};
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
