|
public GenerateCodeFromCompileUnit ( CodeCompileUnit compileUnit, |
||
| compileUnit | CodeCompileUnit | |
| writer | ||
| options | ||
| return | void | |
public static string GenerateString(this CodeCompileUnit self, CodeDomProvider provider)
{
StringBuilder b = new StringBuilder();
using (TextWriter writer = new StringWriter(b))
{
provider.GenerateCodeFromCompileUnit(self, writer, new CodeGeneratorOptions());
}
return b.ToString();
}
public string GetCode(CodeDomProvider codeProdiver, CodeGeneratorOptions generatorOptions)
{
using (var codeStream = new StringWriter())
using (var indentedWriter = new IndentedTextWriter(codeStream, " "))
{
codeProdiver.GenerateCodeFromCompileUnit(_compileUnit, indentedWriter, generatorOptions);
return codeStream.ToString();
}
}
internal string GenerateSource(CodeDomProvider codeProvider)
{
StringBuilder sb = new StringBuilder();
TextWriter tWriter = new IndentedTextWriter(new StringWriter(sb));
CodeCompileUnit ccu = GenerateCode();
codeProvider.GenerateCodeFromCompileUnit(ccu, tWriter, new CodeGeneratorOptions());
codeProvider.Dispose();
tWriter.Close();
return sb.ToString();
}
/// <summary>
/// Convert the abstract representation of the code to functional code given a code provider.
/// </summary>
/// <param name="codeProvider">The code provider.</param>
/// <returns>The code as a string.</returns>
protected string CodeUnitToLanguage(CodeDomProvider codeProvider)
{
var stringBuilder = new StringBuilder();
var stringWriter = new StringWriter(stringBuilder);
var writer = new IndentedTextWriter(stringWriter, TAB_CHARACTER);
codeProvider.GenerateCodeFromCompileUnit(_codeCompileUnit, writer, new CodeGeneratorOptions
{
BlankLinesBetweenMembers = true,
VerbatimOrder = false,
BracingStyle = "C"
});
string output = stringBuilder.ToString().Replace(" { get; set; };\r\n", " { get; set; }\r\n");
return output;
}
public static void GenerateProjectCode (string file, CodeDomProvider provider, GenerationOptions options, ProjectBackend[] projects)
{
CodeGenerationResult res = GenerateProjectCode (options, projects);
string basePath = Path.GetDirectoryName (file);
foreach (SteticCompilationUnit unit in res.Units) {
string fname;
if (unit.Name.Length == 0)
fname = file;
else
fname = Path.Combine (basePath, unit.Name);
StreamWriter fileStream = new StreamWriter (fname);
try {
provider.GenerateCodeFromCompileUnit (unit, fileStream, new CodeGeneratorOptions ());
} finally {
fileStream.Close ();
}
}
}
void Run (string [] args)
{
co.ProcessArgs (args);
if (co.RemainingArguments.Length == 0)
co.DoHelp ();
if (!co.NoLogo)
co.ShowBanner ();
CodeCompileUnit ccu = new CodeCompileUnit ();
CodeNamespace cns = new CodeNamespace (co.Namespace);
ccu.Namespaces.Add (cns);
generator = new ServiceContractGenerator (ccu);
generator.Options = GetGenerationOption ();
code_provider = GetCodeProvider ();
// For now only assemblyPath is supported.
foreach (string arg in co.RemainingArguments) {
FileInfo fi = new FileInfo (arg);
if (!fi.Exists)
throw new ArgumentException (String.Format ("File {0} not found.", fi.Name));
switch (fi.Extension) {
case ".exe":
case ".dll":
GenerateContractType (fi.FullName);
break;
default:
throw new NotSupportedException ("Not supported file extension: " + fi.Extension);
}
}
if (cns.Types.Count == 0) {
Console.Error.WriteLine ("Argument assemblies have no types.");
Environment.Exit (1);
}
using (TextWriter w = File.CreateText (GetOutputFilename ())) {
code_provider.GenerateCodeFromCompileUnit (ccu, w, null);
}
}
// generate code to save on disk
public void GenerateCode(CodeDomProvider provider, CodeCompileUnit compileUnit, string fileName)
{
// Build the source file name with the appropriate
// language extension.
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = fileName + provider.FileExtension;
}
else
{
sourceFile = fileName + "." + provider.FileExtension;
}
// Create an IndentedTextWriter, constructed with
// a StreamWriter to the source file.
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, true), " ");
// Generate source code using the code generator.
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
void WriteCode(CodeDomProvider provider, CodeCompileUnit codeUnit, string fileName)
{
using (StreamWriter fileStream = new StreamWriter(fileName))
{
using (IndentedTextWriter tw = new IndentedTextWriter(fileStream))
{
provider.GenerateCodeFromCompileUnit(codeUnit, tw, new CodeGeneratorOptions());
}
}
}
/// <summary>
/// Generate VB.NET code.
/// </summary>
private static void GenerateCode(string outputPath, CodeCompileUnit compileUnit, CodeDomProvider provider, CodeGeneratorOptions options, DateTime timeStamp)
{
string contents;
using (var stringWriter = new StringWriter())
{
provider.GenerateCodeFromCompileUnit(compileUnit, stringWriter, options);
stringWriter.Flush();
contents = stringWriter.ToString();
const string prefixMarker = "<auto-generated>";
const string postfixMarker = "</auto-generated>";
var startIndex = contents.IndexOf(prefixMarker, StringComparison.Ordinal);
var endIndex = contents.IndexOf(postfixMarker, StringComparison.Ordinal);
if ((startIndex >= 0) && (endIndex >= 0))
{
// Replace auto-generated comment created by .NET.
var prefix = contents.Substring(0, startIndex);
var postfix = contents.Substring(endIndex + postfixMarker.Length);
contents = prefix + "This file is automatically generated by dot42" + postfix;
}
}
// Update file only when it has changed
var existingContents = File.Exists(outputPath) ? File.ReadAllText(outputPath) : "-";
if (contents.Trim() != existingContents.Trim())
{
File.WriteAllText(outputPath, contents);
}
if (File.GetLastWriteTime(outputPath) != timeStamp)
{
// We checked the date to prevent VS from showing the reload dialog
// when nothing has changed.
File.SetLastWriteTime(outputPath, timeStamp);
}
}
protected virtual void GenerateCode(CodeCompileUnit unit, CodeDomProvider provider,
CodeGenerationResults content, string itemPath)
{
CodeCompileUnit cloneUnit = CloneUnit(unit);
foreach (CodeNamespace ns in unit.Namespaces)
{
cloneUnit.Namespaces.Clear();
cloneUnit.Namespaces.Add(CloneNamespace(ns));
foreach (CodeTypeDeclaration codeType in ns.Types)
{
string file = Path.Combine(Path.GetDirectoryName(itemPath),
Path.ChangeExtension(codeType.Name, Path.GetExtension(itemPath)));
if (!content.ContainsFile(file))
{
cloneUnit.Namespaces[0].Types.Clear();
cloneUnit.Namespaces[0].Types.Add(codeType);
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
provider.GenerateCodeFromCompileUnit(cloneUnit, stringWriter, new CodeGeneratorOptions());
content.Add(file, stringWriter.ToString());
}
}
}
}
}
protected string WriteToString(CodeCompileUnit compileUnit, CodeDomProvider provider)
{
var streamWriter = new StringWriter();
using (provider)
{
var textWriter = new IndentedTextWriter(streamWriter, " ");
using (textWriter)
{
using (streamWriter)
{
var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = false };
provider.GenerateCodeFromCompileUnit(compileUnit, textWriter, options);
}
}
}
return CleanupGeneratedFile(streamWriter.ToString());
}
private void CreateStronglyTypedResources( CodeDomProvider provider, TextWriter writer, string resourceName, out string[] errors )
{
CodeCompileUnit ccu = CreateStronglyTypedResourceFile( resourceName, resources,
stronglyTypedClassName, stronglyTypedNamespace, provider, out errors );
CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
codeGenOptions.BlankLinesBetweenMembers = false;
codeGenOptions.BracingStyle = "C";
provider.GenerateCodeFromCompileUnit( ccu, writer, codeGenOptions );
writer.Flush();
}
public static BuildResult GenerateFile (CodeDomProvider provider, string app_name,
string xaml_file, string xaml_path_in_project, string out_file)
{
XmlDocument xmldoc = new XmlDocument ();
xmldoc.Load (xaml_file);
BuildResult result = new BuildResult ();
XmlNamespaceManager nsmgr = new XmlNamespaceManager (xmldoc.NameTable);
nsmgr.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml");
XmlNode root = xmldoc.SelectSingleNode ("/*", nsmgr);
if (root == null) {
result.AddError (xaml_file, 0, 0, "", "No root node found.");
return result;
}
XmlAttribute root_class = root.Attributes ["x:Class"];
if (root_class == null) {
File.WriteAllText (out_file, "");
return result;
}
bool is_application = root.LocalName == "Application";
string root_ns;
string root_type;
string root_asm;
ParseXmlns (root_class.Value, out root_type, out root_ns, out root_asm);
Hashtable names_and_types = GetNamesAndTypes (root, nsmgr);
// Hashtable keys_and_types = GetKeysAndTypes (root, nsmgr);
CodeCompileUnit ccu = new CodeCompileUnit ();
CodeNamespace decl_ns = new CodeNamespace (root_ns);
ccu.Namespaces.Add (decl_ns);
decl_ns.Imports.Add (new CodeNamespaceImport ("System"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Documents"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Input"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media.Animation"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Shapes"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls.Primitives"));
CodeTypeDeclaration decl_type = new CodeTypeDeclaration (root_type);
decl_type.IsPartial = true;
decl_ns.Types.Add (decl_type);
CodeMemberMethod initcomp = new CodeMemberMethod ();
initcomp.Name = "InitializeComponent";
decl_type.Members.Add (initcomp);
if (sl2) {
CodeMemberField field = new CodeMemberField ();
field.Name = "_contentLoaded";
field.Type = new CodeTypeReference (typeof (bool));
decl_type.Members.Add (field);
CodeConditionStatement is_content_loaded = new CodeConditionStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodeStatement [] { new CodeMethodReturnStatement () });
initcomp.Statements.Add (is_content_loaded);
CodeAssignStatement set_content_loaded = new CodeAssignStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodePrimitiveExpression (true));
initcomp.Statements.Add (set_content_loaded);
string component_path = String.Format ("/{0};component/{1}", app_name, xaml_path_in_project);
CodeMethodInvokeExpression load_component = new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression ("System.Windows.Application"), "LoadComponent",
new CodeExpression [] { new CodeThisReferenceExpression (),
new CodeObjectCreateExpression (new CodeTypeReference ("System.Uri"), new CodeExpression [] {
new CodePrimitiveExpression (component_path),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.UriKind"), "Relative") })
});
initcomp.Statements.Add (load_component);
}
if (!is_application) {
foreach (DictionaryEntry entry in names_and_types) {
string name = (string) entry.Key;
CodeTypeReference type = (CodeTypeReference) entry.Value;
CodeMemberField field = new CodeMemberField ();
if (sl2)
field.Attributes = MemberAttributes.Assembly;
field.Name = name;
field.Type = type;
decl_type.Members.Add (field);
CodeMethodInvokeExpression find_invoke = new CodeMethodInvokeExpression (
new CodeThisReferenceExpression(), "FindName",
new CodeExpression[] { new CodePrimitiveExpression (name) } );
CodeCastExpression cast = new CodeCastExpression (type, find_invoke);
CodeAssignStatement assign = new CodeAssignStatement (
new CodeVariableReferenceExpression (name), cast);
initcomp.Statements.Add (assign);
}
}
using (StreamWriter writer = new StreamWriter (out_file)) {
provider.GenerateCodeFromCompileUnit (ccu, writer, new CodeGeneratorOptions ());
}
return result;
}
private static string CreateProxyCode(CodeDomProvider codeDomProvider, CodeCompileUnit codeCompileUnit)
{
string proxyCode;
using (StringWriter writer = new StringWriter())
{
CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
codeGenOptions.BracingStyle = "C";
codeDomProvider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, codeGenOptions);
writer.Flush();
proxyCode = writer.ToString();
}
return proxyCode;
}
/// <summary>
/// This overrides the CodeDomTest Run method that does verification
/// on the tree provided in the BuildTree method you provide.
/// </summary>
/// <param name="provider">Provider to test.</param>
/// <returns>True if the tree builds, compiles, searches and passes
/// assembly verification. False if any of these fails.</returns>
public override bool Run (CodeDomProvider provider) {
bool fail = false;
// build the tree
LogMessageIndent ();
LogMessage ("- Generating tree.");
CodeCompileUnit cu = new CodeCompileUnit ();
LogMessageIndent ();
BuildTree (provider, cu);
LogMessageUnindent ();
// validate tree using 'experimental' subset tester
// but only if the test believes its in the subset
if ((TestType & TestTypes.Subset) != 0) {
SubsetConformance subsConf = new SubsetConformance ();
LogMessage ("- Checking tree subset conformance.");
if (!subsConf.ValidateCodeCompileUnit (cu))
LogMessage ("Failed subset tester: {0}",
subsConf.ToString ());
}
// realize source
StringWriter sw = new StringWriter (CultureInfo.InvariantCulture);
#if WHIDBEY
provider.GenerateCodeFromCompileUnit (cu, sw, GetGeneratorOptions (provider));
#else
ICodeGenerator generator = provider.CreateGenerator ();
generator.GenerateCodeFromCompileUnit (cu, sw, GetGeneratorOptions (provider));
#endif
// only continue if the source could be realized into a string.
if (!fail) {
string source = sw.ToString ();
if (saveSourceFileName.Length > 0) {
LogMessage ("- Saving source into '" + saveSourceFileName + "'");
// save this source to a file
DumpStringToFile (source, saveSourceFileName);
}
// log the source code
//LogMessage (source);
// search the source if the test case asks us to
if (ShouldSearch) {
LogMessageIndent ();
Search (provider, source);
LogMessageUnindent ();
}
// continue only if the test case wants to compile or verify
if (ShouldCompile || ShouldVerify) {
// ask the test case which compiler parameters it would like to use
CompilerParameters parms = GetCompilerParameters (provider);
#if FSHARP
// If the generated code has entrypoint, then F# requires us to generate EXE
bool hasEntryPoint = false;
foreach(CodeNamespace ns in cu.Namespaces)
foreach (CodeTypeDeclaration ty in ns.Types)
foreach(CodeTypeMember mem in ty.Members)
if (mem is CodeEntryPointMethod) { hasEntryPoint = true; }
// If the output file name is specified then it should be EXE
if (hasEntryPoint && parms.GenerateExecutable == false)
{
parms.GenerateExecutable = true;
if (saveAssemblyFileName.ToLower().EndsWith(".dll"))
saveAssemblyFileName = saveAssemblyFileName.Substring(0, saveAssemblyFileName.Length - 4) + ".exe";
}
#endif
// add the appropriate compiler parameters if the user asked us
// to save assemblies to file
if (saveAssemblyFileName.Length > 0) {
parms.OutputAssembly = saveAssemblyFileName;
LogMessage ("- Compiling to '" + saveAssemblyFileName + "'.");
}
// always generate in memory for verification purposes
parms.GenerateInMemory = true;
// compile!
#if WHIDBEY
CompilerResults results = provider.CompileAssemblyFromDom (parms, cu);
#else
ICodeCompiler compiler = provider.CreateCompiler ();
CompilerResults results = compiler.CompileAssemblyFromDom (parms, cu);
#endif
if (results.NativeCompilerReturnValue != 0) {
// compilation failed
fail = true;
LogMessage ("- Compilation failed.");
// log the compilation failed output
foreach (string msg in results.Output)
LogMessage (msg);
} else if (ShouldVerify) {
// compilation suceeded and we are asked to verify the
// compiled assembly
LogMessage ("- Verifying assembly.");
// verify the compiled assembly if it's there
if (results.CompiledAssembly != null) {
LogMessageIndent ();
VerifyAssembly (provider, results.CompiledAssembly);
LogMessageUnindent ();
}
}
}
}
if (fail || !AreAllValidated ()) {
// one of the steps above failed or a scenario was not
// verified within the test case
fail = true;
LogMessage ("! Test '" + Name + "' failed.");
// output failing scenarios
if (!AreAllValidated()) {
LogMessage ("! Failing scenarios:");
foreach (Scenario s in GetNotValidated())
{
LogMessage ("- " + s.ToString());
}
}
} else {
// test passed
LogMessage ("* Test '" + Name + "' passed.");
}
LogMessageUnindent ();
// return true on success, false on failure
return !fail;
}
/////////////////////////////////////////////////////////////////////////////
private static string SourceFromCcu( CodeDomProvider codeProvider, CodeCompileUnit ccu, bool removeLineHidden )
{
// ******
CodeGeneratorOptions options = new CodeGeneratorOptions();
// ******
using( var writer = new StringWriter() ) {
codeProvider.GenerateCodeFromCompileUnit( ccu, writer, options );
string source = writer.ToString();
return removeLineHidden ? RemoveLineHidden(source) : source;
}
}
public CodeGenerationResult GenerateProjectCode (string file, string namespaceName, CodeDomProvider provider, GenerationOptions options, params Project[] projects)
{
ArrayList files = new ArrayList ();
CodeGenerationResult res = GenerateProjectCode (options, projects);
string basePath = Path.GetDirectoryName (file);
string ext = Path.GetExtension (file);
foreach (SteticCompilationUnit unit in res.Units) {
string fname;
if (unit.Name.Length == 0)
fname = file;
else
fname = Path.Combine (basePath, unit.Name) + ext;
files.Add (fname);
unit.Name = fname;
StreamWriter fileStream = new StreamWriter (fname);
try {
provider.GenerateCodeFromCompileUnit (unit, fileStream, new CodeGeneratorOptions ());
} finally {
fileStream.Close ();
}
}
return res;
}
internal static string[] GenerateFiles(CodeDomProvider codeDomProvider, CompilerParameters parameters, CodeCompileUnit[] ccus)
{
CodeGeneratorOptions options = new CodeGeneratorOptions {
BracingStyle = "C"
};
string[] strArray = new string[ccus.Length];
for (int i = 0; i < ccus.Length; i++)
{
ResolveReferencedAssemblies(parameters, ccus[i]);
strArray[i] = parameters.TempFiles.AddExtension(i + codeDomProvider.FileExtension);
Stream stream = new FileStream(strArray[i], FileMode.Create, FileAccess.Write, FileShare.Read);
try
{
using (StreamWriter writer = new StreamWriter(stream, Encoding.UTF8))
{
codeDomProvider.GenerateCodeFromCompileUnit(ccus[i], writer, options);
writer.Flush();
}
}
finally
{
stream.Close();
}
}
return strArray;
}
public static void GenerateCode(CodeCompileUnit unit, CodeDomProvider generator, string target, bool splitToFolders)
{
var genOptions = new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
VerbatimOrder = false,
ElseOnClosing = false,
BracingStyle = "C",
IndentString = " "
};
if (splitToFolders)
{
foreach (var file in MetaFacade.SplitCompileUnit(unit))
{
var fileInfo = new FileInfo(Path.Combine(target, file.Key) + "." + generator.FileExtension);
CheckDirectoryExists(fileInfo.Directory);
using (var sw = fileInfo.CreateText())
{
generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions);
}
}
}
else
{
var fileInfo = new FileInfo(target);
CheckDirectoryExists(fileInfo.Directory);
using (var sw = fileInfo.CreateText())
{
generator.GenerateCodeFromCompileUnit(unit, sw, genOptions);
}
}
}
internal static string[] GenerateFiles(CodeDomProvider codeDomProvider, CompilerParameters parameters, CodeCompileUnit[] ccus)
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
string[] filenames = new string[ccus.Length];
for (int i = 0; i < ccus.Length; i++)
{
ResolveReferencedAssemblies(parameters, ccus[i]);
filenames[i] = parameters.TempFiles.AddExtension(i + codeDomProvider.FileExtension);
Stream temp = new FileStream(filenames[i], FileMode.Create, FileAccess.Write, FileShare.Read);
try
{
using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8))
{
codeDomProvider.GenerateCodeFromCompileUnit(ccus[i], sw, options);
sw.Flush();
}
}
finally
{
temp.Close();
}
}
return filenames;
}
private string GetClassFromCcu(CodeDomProvider provider, CodeCompileUnit ccu)
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
using (StringWriter tw = new StringWriter(CultureInfo.InvariantCulture))
{
provider.GenerateCodeFromCompileUnit(ccu, tw, options);
return tw.ToString();
}
}
public void GenerateProxyClass()
{
EndpointAddress metadataAddress = new EndpointAddress("http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc?wsdl");
//string = "http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc";
string outputFile = @"d:\dev\Sofka\Test\TempFiles";
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
mexClient.ResolveMetadataReferences = false;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
ServiceContractGenerator generator = new ServiceContractGenerator();
// Add our custom DCAnnotationSurrogate
// to write XSD annotations into the comments.
object dataContractImporter;
XsdDataContractImporter xsdDCImporter;
if (!importer.State.TryGetValue(typeof(XsdDataContractImporter), out dataContractImporter))
{
Console.WriteLine("Couldn't find the XsdDataContractImporter! Adding custom importer.");
xsdDCImporter = new XsdDataContractImporter();
xsdDCImporter.Options = new ImportOptions();
importer.State.Add(typeof(XsdDataContractImporter), xsdDCImporter);
}
else
{
xsdDCImporter = (XsdDataContractImporter)dataContractImporter;
if (xsdDCImporter.Options == null)
{
Console.WriteLine("There were no ImportOptions on the importer.");
xsdDCImporter.Options = new ImportOptions();
}
}
//xsdDCImporter.Options.DataContractSurrogate = new DCAnnotationSurrogate();
// Uncomment the following code if you are going to do your work programmatically rather than add
// the WsdlDocumentationImporters through a configuration file.
/*
* // The following code inserts a custom WsdlImporter without removing the other
* // importers already in the collection.
* System.Collections.Generic.IEnumerable<IWsdlImportExtension> exts = importer.WsdlImportExtensions;
* System.Collections.Generic.List<IWsdlImportExtension> newExts
* = new System.Collections.Generic.List<IWsdlImportExtension>();
* foreach (IWsdlImportExtension ext in exts)
* {
* Console.WriteLine("Default WSDL import extensions: {0}", ext.GetType().Name);
* newExts.Add(ext);
* }
* newExts.Add(new WsdlDocumentationImporter());
* System.Collections.Generic.IEnumerable<IPolicyImportExtension> polExts = importer.PolicyImportExtensions;
* importer = new WsdlImporter(metaDocs, polExts, newExts);
*/
System.Collections.ObjectModel.Collection <ContractDescription> contracts
= importer.ImportAllContracts();
importer.ImportAllEndpoints();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
{
throw new Exception("There were errors during code compilation.");
}
// Write the code dom
System.CodeDom.Compiler.CodeGeneratorOptions options
= new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
System.CodeDom.Compiler.CodeDomProvider codeDomProvider
= System.CodeDom.Compiler.CodeDomProvider.CreateProvider("C#");
System.CodeDom.Compiler.IndentedTextWriter textWriter
= new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
codeDomProvider.GenerateCodeFromCompileUnit(
generator.TargetCompileUnit, textWriter, options
);
textWriter.Close();
}
private static void GenerateCode(string sourceFileName, CodeDomProvider provider, CodeCompileUnit compileunit)
{
var tw = new IndentedTextWriter(new StreamWriter(sourceFileName, false), " ");
provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
tw.Close();
}
internal static int GetGeneratedColumnOffset(CodeDomProvider codeDomProvider) {
object o = null;
if (_generatedColumnOffsetDictionary == null) {
_generatedColumnOffsetDictionary = new ListDictionary();
}
else {
o = _generatedColumnOffsetDictionary[codeDomProvider.GetType()];
}
if (o == null) {
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cnamespace = new CodeNamespace("ASP");
ccu.Namespaces.Add(cnamespace);
CodeTypeDeclaration type = new CodeTypeDeclaration("ColumnOffsetCalculator");
type.IsClass = true;
cnamespace.Types.Add(type);
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = new CodeTypeReference(typeof(void));
method.Name = "GenerateMethod";
type.Members.Add(method);
CodeStatement simpleAssignment = new CodeAssignStatement(
new CodeVariableReferenceExpression(BaseTemplateCodeDomTreeGenerator.tempObjectVariable),
new CodeSnippetExpression(_dummyVariable));
method.Statements.Add(simpleAssignment);
StringBuilder sb = new StringBuilder();
StringWriter w = new StringWriter(sb, CultureInfo.InvariantCulture);
codeDomProvider.GenerateCodeFromCompileUnit(ccu, w, null);
StringReader reader = new StringReader(sb.ToString());
String line = null;
int offset = _defaultColumnOffset;
while ((line = reader.ReadLine()) != null) {
int index = 0;
line = line.TrimStart();
if ((index = line.IndexOf(_dummyVariable, StringComparison.Ordinal)) != -1) {
offset = index - BaseTemplateCodeDomTreeGenerator.tempObjectVariable.Length + 1;
}
}
// Save the offset per type.
_generatedColumnOffsetDictionary[codeDomProvider.GetType()] = offset;
return offset;
}
return (int)o;
}
/// <summary>
/// Generates the required code using the specified compile unit.
/// </summary>
/// <param name="codeDom">The code DOM provider.</param>
/// <param name="codeGenerator">The code generator.</param>
/// <param name="builder">The string builder used to write the code.</param>
private static void GenerateCode(CodeDomProvider codeDom, RazorCodeGenerator codeGenerator, StringBuilder builder)
{
// removed so the output is compatible with standard WebViewPage
// var statement = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Clear");
// codeGenerator.GeneratedExecuteMethod.Statements.Insert(0, new CodeExpressionStatement(statement));
using (var writer = new StringWriter(builder))
{
codeDom.GenerateCodeFromCompileUnit(codeGenerator.GeneratedCode, writer, new CodeGeneratorOptions());
}
}
void Run (string [] args)
{
co.ProcessArgs (args);
if (co.RemainingArguments.Length == 0) {
co.DoHelp ();
return;
}
if (!co.NoLogo)
co.ShowBanner ();
CodeCompileUnit ccu = new CodeCompileUnit ();
CodeNamespace cns = new CodeNamespace (co.Namespace);
ccu.Namespaces.Add (cns);
generator = new ServiceContractGenerator (ccu);
generator.Options = GetGenerationOption ();
generator.Options |=ServiceContractGenerationOptions.ChannelInterface;
code_provider = GetCodeProvider ();
MetadataSet metadata = null;
// For now only assemblyPath is supported.
foreach (string arg in co.RemainingArguments) {
Uri uri = null;
if (Uri.TryCreate (arg, UriKind.Absolute, out uri)) {
metadata = ResolveWithDisco (arg);
if (metadata == null)
metadata = ResolveWithWSMex (arg);
continue;
}
FileInfo fi = new FileInfo (arg);
if (!fi.Exists)
switch (fi.Extension) {
case ".exe":
case ".dll":
GenerateContractType (fi.FullName);
break;
default:
throw new NotSupportedException ("Not supported file extension: " + fi.Extension);
}
}
if (metadata == null)
return;
List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
list.Add (new TransportBindingElementImporter ());
//list.Add (new DataContractSerializerMessageContractImporter ());
list.Add (new XmlSerializerMessageContractImporter ());
//WsdlImporter importer = new WsdlImporter (metadata, null, list);
WsdlImporter importer = new WsdlImporter (metadata);
//ServiceEndpointCollection endpoints = importer.ImportAllEndpoints ();
Console.WriteLine ("Generating files..");
/*foreach (ServiceEndpoint se in endpoints)
generator.GenerateServiceContractType (se.Contract);*/
Collection<ContractDescription> contracts = importer.ImportAllContracts ();
foreach (ContractDescription cd in contracts)
generator.GenerateServiceContractType (cd);
/*if (cns.Types.Count == 0) {
Console.Error.WriteLine ("Argument assemblies have no types.");
Environment.Exit (1);
}*/
//FIXME: Generate .config
Console.WriteLine (GetOutputFilename ());
using (TextWriter w = File.CreateText (GetOutputFilename ())) {
code_provider.GenerateCodeFromCompileUnit (ccu, w, null);
}
}
/// <summary>
/// Gets the code generated for the code unit.
/// </summary>
/// <param assemblyFullName="?"></param>
/// <returns></returns>
public static Stream GenerateCodeAsStream(CodeCompileUnit codeCompileUnit, CodeDomProvider codeDomProvider, CodeGeneratorOptions generatorOptions)
{
var memStream = new MemoryStream();
var textWriter = new StreamWriter(memStream);
codeDomProvider.GenerateCodeFromCompileUnit(codeCompileUnit, textWriter, generatorOptions);
textWriter.Flush();
memStream.Position = 0;
return memStream;
}
/// <summary>
/// Write code to the given stream from the compile unit.
/// </summary>
/// <param name="sourceWriter"></param>
/// <param name="provider"></param>
/// <param name="compileUnit"></param>
private static void GenerateCode(TextWriter sourceWriter, CodeDomProvider provider, CodeCompileUnit compileUnit)
{
CodeGeneratorOptions styleOptions = new CodeGeneratorOptions();
styleOptions.BracingStyle = "C";
styleOptions.BlankLinesBetweenMembers = true;
styleOptions.VerbatimOrder = true;
provider.GenerateCodeFromCompileUnit(compileUnit, sourceWriter, styleOptions);
}
public CodeGenerationResult GenerateProjectCode (string file, string namespaceName, CodeDomProvider provider, GenerationOptions options, params Project[] projects)
{
ArrayList files = new ArrayList ();
CodeGenerationResult res = GenerateProjectCode (options, projects);
string basePath = Path.GetDirectoryName (file);
string ext = Path.GetExtension (file);
foreach (SteticCompilationUnit unit in res.Units) {
string fname;
if (unit.Name.Length == 0) {
if (provider is Microsoft.CSharp.CSharpCodeProvider && unit.Namespaces.Count > 0) {
var types = unit.Namespaces [0].Types;
if (types.Count > 0) {
types [0].Members.Insert (0, new CodeSnippetTypeMember ("#pragma warning disable 436"));
}
}
fname = file;
} else
fname = Path.Combine (basePath, unit.Name) + ext;
files.Add (fname);
unit.Name = fname;
StreamWriter fileStream = new StreamWriter (fname);
try {
provider.GenerateCodeFromCompileUnit (unit, fileStream, new CodeGeneratorOptions ());
} finally {
fileStream.Close ();
}
}
return res;
}
private string[] GetCompilationSource(CodeDomProvider provider, CodeCompileUnit generatedCode)
{
var compilationSourceBuilder = new StringBuilder();
using (var writer = new IndentedTextWriter(new StringWriter(compilationSourceBuilder), "\t"))
{
provider.GenerateCodeFromCompileUnit(generatedCode, writer, new CodeGeneratorOptions());
}
var compilationSource = compilationSourceBuilder.ToString();
return HttpUtility.HtmlEncode(compilationSource)
.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
}
public string Generate(CodeDomProvider codeGen)
{
StringWriter w = new StringWriter();
codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null);
return w.ToString();
}
