private static string GenerateCode(ResourceTypeBuilder builder, CodeDomProvider provider)
{
var code = builder.Build( );
var source = new StringBuilder( );
var generator = new ExtendedCodeGenerator(provider);
using (var writer = new StringWriter(source))
generator.GenerateCodeFromCompileUnit(code, writer, null);
return(source.ToString( ));
}
protected override byte [] GenerateCode(string inputFileName, string inputFileContent)
{
ThreadHelper.ThrowIfNotOnUIThread( );
var fileBased = ProjectItem.Properties.Item("ItemType").Value?.ToString( ) != "EmbeddedResource";
var hasLinguist = Project.HasReference("Linguist");
var hasLinguistWPF = Project.HasReference("Linguist.WPF");
var hasLinguistXamarinForms = Project.HasReference("Linguist.Xamarin.Forms");
hasLinguist = hasLinguist || hasLinguistWPF || hasLinguistXamarinForms;
var resourceSet = ResourceExtractor.ExtractResources(inputFileName, inputFileContent);
var settings = new ResourceTypeSettings( );
var baseName = Path.GetFileNameWithoutExtension(inputFileName);
var manifestPath = GetDefaultNamespace( );
var relativePath = Path.Combine(Project.Name, Path.Combine(manifestPath.Substring(Project.Name.Length).Split('.')));
settings.ClassName = baseName;
settings.Namespace = FileNamespace ?? manifestPath;
settings.AccessModifiers = AccessModifier;
settings.CustomToolType = GetType( );
settings.Extension = hasLinguistWPF ? ResourceTypeExtension.WPF :
hasLinguistXamarinForms ? ResourceTypeExtension.XamarinForms :
ResourceTypeExtension.None;
if (fileBased)
{
settings.ConfigureFileBasedResourceManager(baseName, Path.Combine(relativePath, Path.GetFileName(inputFileName)));
}
else if (hasLinguist)
{
settings.ConfigureResourceManager(manifestPath + '.' + baseName);
}
else
{
settings.ConfigureWithoutLocalizer(manifestPath + '.' + baseName);
}
var builder = new ResourceTypeBuilder(CodeDomProvider, resourceSet, settings);
var code = builder.Build( );
var errors = builder.GetErrors( );
var source = new StringBuilder( );
var generator = new ExtendedCodeGenerator(CodeDomProvider);
using (var writer = new StringWriter(source))
generator.GenerateCodeFromCompileUnit(code, writer, null);
if (errors != null)
{
foreach (var error in errors)
{
GeneratorErrorCallback(error.IsWarning, default, error.ErrorText, error.Line, error.Column);
/// <summary>
/// Generates code for the specified Code Document Object Model (CodeDOM) compilation unit and
/// outputs it to the specified a string.
/// </summary>
/// <param name="codeUnit">A <see cref="CodeCompileUnit"/> to generate code for.</param>
/// <returns>The generated code.</returns>
protected virtual string GenerateCodeFromCompileUnit(CodeCompileUnit codeUnit)
{
ExtendedCodeGenerator generator = this.language.CreateCodeGenerator();
StringBuilder sb = new StringBuilder();
using (var stringWriter = new StringWriter(sb, CultureInfo.InvariantCulture))
{
var options = new SafeCodeGeneratorOptions()
{
BracingStyle = "C",
IndentString = " ",
};
generator.GenerateCodeFromCompileUnit(codeUnit, stringWriter, options);
}
return(sb.ToString());
}
/// <summary>
/// Runs all this.variations and executes the specified continuation at the end.
/// </summary>
/// <param name="continuation">The continuation to execute at the end of execution.</param>
public override void RunVariations(IAsyncContinuation continuation)
{
// Build CodeDOM tree
var codeUnit = this.BuildCompiledCodeUnit();
// Generate code
ExtendedCodeGenerator generator = this.language.CreateCodeGenerator();
var options = new SafeCodeGeneratorOptions()
{
BracingStyle = "C",
IndentString = " ",
};
this.generatedCode = generator.GenerateCodeFromCompileUnit(codeUnit, options);
this.Log.WriteLine(LogLevel.Trace, this.generatedCode);
this.CompileAndRunVariations(continuation, this.generatedCode);
}
/// <summary>
/// Generates the service method code from CodeDom
/// </summary>
/// <param name="statements">a collection of CodeDom statements</param>
/// <param name="model">the EntityModelSchema</param>
/// <returns>the service method code</returns>
protected virtual string GenerateMethodCode(IEnumerable <CodeStatement> statements, EntityModelSchema model)
{
ExtendedCodeGenerator codeGen = this.Language.CreateCodeGenerator();
return(string.Join(Environment.NewLine, statements.Select(s => codeGen.GenerateCodeFromStatement(s))));
}
internal ExtendedCSharpTreeRewriter(ExtendedCodeGenerator generator)
{
this.generator = generator;
}
protected string GenerateCode(CodeDomProvider codeDomProvider, string rootNamespace, string inputFileName, IResource [] resourceSet, bool hasLinguist, bool hasLinguistWPF, bool hasLinguistXamarinForms, out string baseName, out string manifestPath)
{
var fileBased = false;
hasLinguist = hasLinguist || hasLinguistWPF || hasLinguistXamarinForms;
var settings = new ResourceTypeSettings( );
baseName = Path.GetFileNameWithoutExtension(inputFileName);
var basePath = Path.GetDirectoryName(inputFileName).Replace('\\', '.').Replace('\\', '.');
manifestPath = rootNamespace;
if (!string.IsNullOrEmpty(basePath))
{
manifestPath += "." + basePath;
}
var relativePath = Path.Combine(rootNamespace, Path.Combine(manifestPath.Substring(rootNamespace.Length).Split('.')));
var accessModifier = System.CodeDom.MemberAttributes.Assembly | System.CodeDom.MemberAttributes.Static;
settings.ClassName = baseName;
settings.Namespace = manifestPath;
settings.AccessModifiers = accessModifier;
settings.CustomToolType = GetType( );
settings.Extension = hasLinguistWPF ? ResourceTypeExtension.WPF :
hasLinguistXamarinForms ? ResourceTypeExtension.XamarinForms :
ResourceTypeExtension.None;
if (fileBased)
{
settings.ConfigureFileBasedResourceManager(baseName, Path.Combine(relativePath, Path.GetFileName(inputFileName)));
}
else if (hasLinguist)
{
settings.ConfigureResourceManager(manifestPath + '.' + baseName);
}
else
{
settings.ConfigureWithoutLocalizer(manifestPath + '.' + baseName);
}
var builder = new ResourceTypeBuilder(codeDomProvider, resourceSet, settings);
var code = builder.Build( );
var errors = builder.GetErrors( );
var source = new StringBuilder( );
var generator = new ExtendedCodeGenerator(codeDomProvider);
using (var writer = new StringWriter(source))
generator.GenerateCodeFromCompileUnit(code, writer, null);
if (errors != null)
{
foreach (var error in errors)
{
if (error.IsWarning)
{
Log.LogWarning(error.ToString( ));
}
else
{
Log.LogError(error.ToString( ));
}
}
}
var output = Path.ChangeExtension(inputFileName, codeDomProvider.FileExtension);
using (var stream = File.Open(output, FileMode.Create, FileAccess.Write))
using (var writer = new StreamWriter(stream, Encoding.UTF8))
generator.GenerateCodeFromCompileUnit(code, writer, null);
return(output);
}
