static void CompileLocations(string outputFile)
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Desklet.Weather");
unit.Namespaces.Add(ns);
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
MainClass = new CodeTypeDeclaration("Locations");
MainClass.TypeAttributes = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public;
MainClass.IsPartial = true;
ns.Types.Add(MainClass);
CodeMemberMethod buildData = new CodeMemberMethod();
buildData.Name = "BuildData";
GenerateBuildData(buildData);
MainClass.Members.Add(buildData);
CodeDomProvider provider = new CSharpCodeProvider();
ICodeGenerator gen = provider.CreateGenerator();
TextWriter tw = new IndentedTextWriter(new StreamWriter(outputFile, false), "\t");
gen.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());
tw.Close();
}
public void SaveAssembly()
{
myassembly = new CodeCompileUnit();
myassembly.Namespaces.Add(mynamespace);
CompilerParameters comparam = new CompilerParameters(new string[] { "mscorlib.dll" });
comparam.ReferencedAssemblies.Add("System.dll");
comparam.GenerateInMemory = false;
comparam.GenerateExecutable = true;
comparam.MainClass = "mynamespace.Myclass";
comparam.OutputAssembly = @"c:\temp\HelloWorld.exe";
Microsoft.CSharp.CSharpCodeProvider ccp = new Microsoft.CSharp.CSharpCodeProvider();
StreamWriter sw = new StreamWriter(@"c:\temp\HelloWorld.cs");
// ez is jo:
// IndentedTextWriter
// ???
IndentedTextWriter idt = new IndentedTextWriter(sw, " ");
idt.Indent = 1;
ICodeGenerator cscg = ccp.CreateGenerator(idt);
ICodeCompiler icc = ccp.CreateCompiler();
CompilerResults compres = icc.CompileAssemblyFromDom(comparam, myassembly);
cscg.GenerateCodeFromNamespace(mynamespace, idt, new CodeGeneratorOptions());
idt.Close();
if (compres == null || compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
}
private static string GenerateCSharpCode(string fileName, CodeCompileUnit compileunit)
{
// Generate the code with the C# code provider.
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the output file name.
string sourceFile = fileName;
// check directory
string directory = Path.GetDirectoryName(fileName);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// Create a TextWriter to a StreamWriter to the output file.
using (StreamWriter sw = new StreamWriter(sourceFile, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
return(sourceFile);
}
/// <summary>
/// Writes the current code scope to file.
/// </summary>
/// <param name="fileName">File name to write the code to.</param>
public void WriteToFile(string fileName)
{
// Create a new CSharpCodeProvider to generate the code for us.
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
// Create a new stream writer to write the file.
using (StreamWriter writer = new StreamWriter(fileName))
{
// Create a new IndentedTextWriter to format the code is a nice mannor.
IndentedTextWriter tw = new IndentedTextWriter(writer, " ");
// Setup the code generation options for style preferences.
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
options.BracingStyle = "C";
options.VerbatimOrder = false;
// Generate the code using the code provider.
codeProvider.GenerateCodeFromCompileUnit(this.codeUnit, tw, options);
// Close the text writer.
tw.Close();
}
// Dispose of the code provider.
codeProvider.Dispose();
}
void GenerateFile(string filenameSuffix, IEnumerable <CodeTypeDeclaration> types)
{
var globalNamespace = new CodeNamespace
{
Imports =
{
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Linq"),
new CodeNamespaceImport("System.Collections.Generic"),
new CodeNamespaceImport("System.ComponentModel")
}
};
var codeNamespace = new CodeNamespace("Fix");
codeNamespace.Types.AddRange(types.ToArray());
var codeUnit = new CodeCompileUnit
{
Namespaces = { globalNamespace, codeNamespace }
};
var codeProvider = new CSharpCodeProvider();
string filename = OutputPath + Path.DirectorySeparatorChar + string.Format("Dictionary{0}.", string.IsNullOrEmpty(filenameSuffix) ? "" : "_" + filenameSuffix.Replace(".", "_")) + codeProvider.FileExtension;
var writer = new IndentedTextWriter(new StreamWriter(filename, false), " ");
codeProvider.GenerateCodeFromCompileUnit(codeUnit, writer, new CodeGeneratorOptions());
writer.Close();
}
private void button1_Click(object sender, EventArgs e)
{
var unit = new CodeCompileUnit();
var dynamucNamespace = new CodeNamespace("FourthCoffee.Dynamic");
unit.Namespaces.Add(dynamucNamespace);
dynamucNamespace.Imports.Add(new CodeNamespaceImport("System"));
var programType = new CodeTypeDeclaration("Program");
dynamucNamespace.Types.Add(programType);
var mainMethod = new CodeEntryPointMethod();
programType.Members.Add(mainMethod);
var expression = new CodeMethodInvokeExpression
(new CodeTypeReferenceExpression("Console"), "WriteLine",
new CodePrimitiveExpression("Hello Development Team!!!"));
mainMethod.Statements.Add(expression);
var provider = new CSharpCodeProvider();
var filename = "program.cs";
var stream = new StreamWriter(filename);
var textWriter = new IndentedTextWriter(stream);
var options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
// var compileUnit = FourthCoffee.GetModel();
provider.GenerateCodeFromCompileUnit(unit, textWriter, options);
textWriter.Close();
stream.Close();
}
private void WriteCodeFile(string filePath, AddClasses addClasses)
{
var provider = new CSharpCodeProvider();
var compileUnit = new CodeCompileUnit();
var Classes = new CodeNamespace($"GSharp.Generated.{Configuration.GetSubFolder(interfaceList.Source)}");
compileUnit.Namespaces.Add(Classes);
Classes.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
Classes.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
foreach (var name in interfaceList.Namespaces)
{
Classes.Imports.Add(new CodeNamespaceImport(name));
}
addClasses(Classes);
using (StreamWriter sw = new StreamWriter(filePath, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
tw.Close();
}
}
/// <summary>
/// Writes CodeCompileUnits from list <c>files</c> to folder "./classes/" under their respective names
/// in files representing C# classes
/// </summary>
public void WriteFiles()
{
OnMessage("\r\n\t--------------Writing files--------------");
int counter = 0;
foreach (CodeCompileUnit unit in Files)
{
if (unit != null)
{
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = @".\Classes\" + unit.Namespaces[0].Types[0].Name + provider.FileExtension;
}
else
{
sourceFile = @".\Classes\" + unit.Namespaces[0].Types[0].Name + "." + provider.FileExtension;
}
if (!System.IO.Directory.Exists(@".\Classes\"))
{
System.IO.Directory.CreateDirectory(@".\Classes\");
}
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
provider.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());
tw.Close();
counter++;
}
}
OnMessage("\r\nTOTAL UNITS:" + counter);
OnMessage("\r\n\t----------Done writing files----------");
}
public static string GenerateCSharpCode(string path,
string ns,
string className,
string fileName,
Func <List <CodeTypeMember> > action)
{
var _compileunit = new CodeCompileUnit();
var @namespace = new CodeNamespace(ns);
var @class = new CodeTypeDeclaration(className);
@class.IsPartial = true;
@class.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
@namespace.Types.Add(@class);
foreach (var member in action.Invoke())
{
@class.Members.Add(member);
}
_compileunit.Namespaces.Add(@namespace);
var provider = new CSharpCodeProvider();
var sourceFile = $"{Path.Combine(path, fileName ?? className)}{(provider.FileExtension[0] == '.' ? ' ' : '.')}{provider.FileExtension}";
using (StreamWriter sw = new StreamWriter(sourceFile, false))
{
var tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(_compileunit, tw, new CodeGeneratorOptions());
tw.Close();
}
return(sourceFile);
}
public static StringBuilder GenerateCode(this CodeNamespace self)
{
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(self);
CSharpCodeProvider provider = new CSharpCodeProvider();
MemoryStream mem = new MemoryStream();
using (StreamWriter sw = new StreamWriter(mem, System.Text.Encoding.UTF8))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
var sb = new StringBuilder(System.Text.Encoding.UTF8.GetString(mem.ToArray()));
return(sb);
}
static String OutFile(CodeDomProvider provider, String str, String fName)
{
String sourceFile;
//也可以构建该类，生成结构
CodeCompileUnit compileUnit = new CodeCompileUnit();
if (provider.FileExtension[0] == '.')
{
sourceFile = fName + "." + provider.FileExtension;
}
else
{
sourceFile = fName + "." + provider.FileExtension;
}
String modelsDir = BinPaht + @"\Codes\";
if (!System.IO.Directory.Exists(modelsDir))
{
//文件夹不存在则创建该文件夹
System.IO.Directory.CreateDirectory(modelsDir);
}
sourceFile = modelsDir + sourceFile;
// Create a TextWriter to a StreamWriter to an output file.
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
// Generate source code using the code provider.
tw.WriteLine(str);
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
return(sourceFile);
}
public override string CreateOutput()
{
RemoveComments = Generators.Any(p => !p.AlwaysRegenerate);
Namespace = new CodeNamespace(NamespaceName);
Unit = new CodeCompileUnit();
Unit.Namespaces.Add(Namespace);
foreach (var codeGenerator in Generators.Where(p => p.IsValid()))
{
// UnityEngine.Debug.Log(codeGenerator.GetType().Name + " is generating");
codeGenerator.Initialize(this);
}
var provider = new CSharpCodeProvider();
var sb = new StringBuilder();
var tw1 = new IndentedTextWriter(new StringWriter(sb), " ");
provider.GenerateCodeFromCompileUnit(Unit, tw1, new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
BracingStyle = "C"
});
tw1.Close();
if (RemoveComments)
{
var removedLines = sb.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.None).Skip(10).ToArray();
return(string.Join(Environment.NewLine, removedLines));
}
return(sb.ToString());
}
/// <summary>
/// Generates the given service saving to the outputFile in the language passed in.
/// </summary>
public static void GenerateService(string serviceName,
string version,
string clientNamespace,
string language,
string outputFile)
{
// Generate the discovery URL for that service
string url = string.Format(GoogleDiscoveryURL, serviceName, version);
var discovery = CreateDefaultCachingDiscovery(url);
// Build the service based on discovery information.
var service = discovery.GetService(DiscoveryVersion.Version_1_0, new FactoryParameters());
var generator = new GoogleServiceGenerator(service, clientNamespace);
var generatedCode = generator.GenerateCode();
var provider = CodeDomProvider.CreateProvider(language);
using (StreamWriter sw = new StreamWriter(outputFile, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(generatedCode, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
}
public void GenerateCode(CodeCompileUnit ccu, string codeProvider)
{
CompilerParameters cp = new CompilerParameters();
string sourceFile;
CompilerResults cr;
switch (codeProvider)
{
case "CSHARP":
{
CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider();
if (cSharpCodeProvider.FileExtension[0] == '.')
{
sourceFile = "CSharpSample" + cSharpCodeProvider.FileExtension; // CSharpSample.exe
}
else
{
sourceFile = "CSharpSample." + cSharpCodeProvider.FileExtension;
}
IndentedTextWriter tw1 = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
cSharpCodeProvider.GenerateCodeFromCompileUnit(ccu, tw1, new CodeGeneratorOptions());
tw1.Close();
cp.GenerateExecutable = true;
cp.OutputAssembly = "CSharpSample.exe";
cp.GenerateInMemory = false;
break;
}
}
}
//</Snippet2>
//<Snippet3>
public static void GenerateCode(CodeDomProvider provider,
CodeCompileUnit compileunit)
{
// Build the source file name with the appropriate
// language extension.
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = "TestGraph" + provider.FileExtension;
}
else
{
sourceFile = "TestGraph." + provider.FileExtension;
}
// Create an IndentedTextWriter, constructed with
// a StreamWriter to the source file.
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
// Generate source code using the code generator.
provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
public static String GenerateCode(CodeDomProvider provider,
CodeCompileUnit compileunit)
{
// Build the source file name with the language
// extension (vb, cs, js).
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = "HelloWorld" + provider.FileExtension;
}
else
{
sourceFile = "HelloWorld." + provider.FileExtension;
}
// Create a TextWriter to a StreamWriter to an output file.
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
return(sourceFile);
}
public static void GenerateCode(
CodeCompileUnit unit,
string schemaName)
{
var provider = CodeDomProvider.CreateProvider("CSharp");
var destinationFolder = GeneratedControllersFolder;
Directory.CreateDirectory(destinationFolder);
var fileName = Path.Join(
destinationFolder,
$"{schemaName}.{provider.FileExtension}"
);
using var textWriter = new IndentedTextWriter(
new StreamWriter(fileName, append: false),
" "
);
provider.GenerateCodeFromCompileUnit(
unit,
textWriter,
new CodeGeneratorOptions()
);
textWriter.Close();
}
public static void Test_Using_CodeDOM()
{
CodeCompileUnit compileUnit = new CodeCompileUnit(); // file
CodeNamespace myNamespace = new CodeNamespace("MyNamespace"); // namespace
myNamespace.Imports.Add(new CodeNamespaceImport("System")); // using System;
CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass"); // class
CodeEntryPointMethod start = new CodeEntryPointMethod(); // main method
CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression( // method
new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World!"));
CodeMethodInvokeExpression cs2 = new CodeMethodInvokeExpression( // method
new CodeTypeReferenceExpression("Console"), "ReadLine");
compileUnit.Namespaces.Add(myNamespace); // add namespace to file
myNamespace.Types.Add(myClass); // add class to namespace
myClass.Members.Add(start); // add main function to myClass
start.Statements.Add(cs1); // add cs1 and cs2 to main method
start.Statements.Add(cs2);
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StreamWriter sw = new StreamWriter("HelloWorld.cs", false)) // the output file path is: C:\Visual_Studio_Project\DotNet_Projects\ExamRef_70_483_Chapter1\ExamRef_70_483_Chapter2\bin\Debug
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new System.CodeDom.Compiler.CodeGeneratorOptions());
tw.Close();
}
}
/// <summary>
/// Generates a value type implementation for forValueType.
/// </summary>
/// <returns>true if generated, false if skipped</returns>
public bool GenerateValueTypeImpl(Type forValueType)
{
// create the fileName from targetDirectory and
// full type name
string fileName = forValueType.FullName;
fileName = fileName.Replace(".", "_") + "." + m_codeDomProvider.FileExtension;
fileName = Path.Combine(m_targetDir.FullName, fileName);
if (File.Exists(fileName) && !m_overwriteWhenExist)
{
Console.WriteLine("skip generation for " +
forValueType.FullName +
" because implementation file " +
fileName + " already exists ");
return(false);
}
StreamWriter targetStream = new StreamWriter(fileName, false);
IndentedTextWriter writer = new IndentedTextWriter(targetStream);
GenerateValueTypeImplToFile(forValueType, writer);
writer.Flush();
writer.Close();
return(true);
}
public void GenerateDefaultClass(string fileName, string className, string namespaceName)
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace myNamespace = new CodeNamespace(namespaceName);
CodeTypeDeclaration myClass = new CodeTypeDeclaration(className)
{
Attributes = MemberAttributes.Public | MemberAttributes.Static
};
var start = new CodeMemberMethod
{
Name = "Start",
Attributes = MemberAttributes.Public | MemberAttributes.Static
};
compileUnit.Namespaces.Add(myNamespace);
myNamespace.Types.Add(myClass);
myClass.Members.Add(start);
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StreamWriter sw = new StreamWriter(fileName, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw,
new CodeGeneratorOptions());
tw.Close();
}
}
private static void GenerateCSharpCode(CodeCompileUnit compileUnit)
{
// Generate the code with the C# code provider.
var provider = new CSharpCodeProvider();
// Build the output file name.
string sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = "HelloWorld" + provider.FileExtension;
}
else
{
sourceFile = "HelloWorld." + provider.FileExtension;
}
// Create a TextWriter to a StreamWriter to the output file.
using (StreamWriter sw = new StreamWriter(Path.Combine(Path.GetTempPath(), sourceFile), false))
{
var tw = new IndentedTextWriter(sw, "\t");
// Generate source code using the code provider.
var generatorOptions = new CodeGeneratorOptions();
generatorOptions.IndentString = "\t";
generatorOptions.BlankLinesBetweenMembers = false;
provider.GenerateCodeFromCompileUnit(compileUnit, tw, generatorOptions);
// Close the output file.
tw.Close();
}
}
public virtual void CreateSettingsScript(string scriptName, List <string> keys)
{
string copyPath = QuickBaseEditor.GetScriptPath(scriptName);
if (copyPath.Length == 0)
{
copyPath = "Assets/" + scriptName + ".cs";
}
Debug.Log("Creating Custom Settings Script: " + copyPath);
IndentedTextWriter outFile = new IndentedTextWriter(new StreamWriter(copyPath));
outFile.WriteLine("using UnityEngine;");
outFile.WriteLine("using QuickVR;");
outFile.WriteLine("");
outFile.WriteLine("public static class " + scriptName);
outFile.WriteLine("{");
outFile.WriteLine();
WriteNestedTypes(scriptName, outFile);
outFile.WriteLine();
WriteGettersAndSetters(keys, outFile);
outFile.WriteLine();
outFile.WriteLine("}");
outFile.Close();
AssetDatabase.ImportAsset(copyPath);
AssetDatabase.Refresh();
}
static String OutFile(CodeDomProvider provider, String str)
{
String sourceFile;
//也可以构建该类，生成结构
CodeCompileUnit compileUnit = new CodeCompileUnit();
if (provider.FileExtension[0] == '.')
{
sourceFile = "HelloWorld" + provider.FileExtension;
}
else
{
sourceFile = "HelloWorld." + provider.FileExtension;
}
sourceFile = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath + @"\" + sourceFile;
// Create a TextWriter to a StreamWriter to an output file.
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
// Generate source code using the code provider.
tw.WriteLine(str);
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
return(sourceFile);
}
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();
}
public void CreateAHelloWorld()
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace("XNamespace");
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration myclass = new CodeTypeDeclaration("myClass");
CodeEntryPointMethod start = new CodeEntryPointMethod();
CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World!"));
compileUnit.Namespaces.Add(codeNamespace);
codeNamespace.Types.Add(myclass);
myclass.Members.Add(start);
start.Statements.Add(cs1);
//create a source file
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StreamWriter sw = new StreamWriter("helloworld.cs", false)) {
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
tw.Close();
}
}
public void WriteCoreLibSource(AssemblyIdentity identity, bool isCoreLib)
{
if (!isCoreLib)
{
return;
}
// write header
var text = new StringBuilder();
using (var itw = new IndentedTextWriter(new StringWriter(text)))
{
WriteSourceInclude(itw, identity);
itw.WriteLine(Resources.c_definitions);
itw.WriteLine(Resources.intrin);
itw.WriteLine(Resources.decimals);
itw.Close();
}
var newText = text.ToString();
var path = this.GetPath(identity.Name, subFolder: "src", ext: ".cpp");
if (IsNothingChanged(path, newText))
{
return;
}
using (var textFile = new StreamWriter(path))
{
textFile.Write(newText);
}
}
static void Main(string[] args)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = false;
parameters.ReferencedAssemblies.Add("netstandard.dll");
parameters.ReferencedAssemblies.Add("System.Composition.AttributedModel.dll");
parameters.ReferencedAssemblies.Add("MEFdlls.dll");
parameters.OutputAssembly = "C:/temp/NewMEF.dll";
CodeCompileUnit compileUnit = BuildNewMefGraph();
string sourceFile = "NewMEF." + provider.FileExtension;
using (StreamWriter sw = new StreamWriter(sourceFile, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw,
new CodeGeneratorOptions());
tw.Close();
}
CompilerResults results = provider.CompileAssemblyFromDom(parameters, compileUnit);
var s = results.PathToAssembly;
}
public static string GenerateCSharpCode(CodeCompileUnit compileunit)
{
// Generate the code with the C# code provider.
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the output file name.
string sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = "HelloWorld" + provider.FileExtension;
}
else
{
sourceFile = "HelloWorld." + provider.FileExtension;
}
// Create a TextWriter to a StreamWriter to the output file.
using (StreamWriter sw = new StreamWriter(sourceFile, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
// Close the output file.
tw.Close();
}
return(sourceFile);
}
public static String GenerateCode(CodeDomProvider provider,
CodeCompileUnit compileUnit)
{
// Build the source file name with the language
// extension (vb, cs, js).
String sourceFile = "";
// Write the source out in the selected language if
// the code generator supports partial type declarations.
if (provider.Supports(GeneratorSupport.PartialTypes))
{
if (provider.FileExtension[0] == '.')
{
sourceFile = "DocProp" + provider.FileExtension;
}
else
{
sourceFile = "DocProp." + provider.FileExtension;
}
// Create a TextWriter to a StreamWriter to an output file.
IndentedTextWriter outWriter = new IndentedTextWriter(new
StreamWriter(sourceFile, false), " ");
// Generate source code using the code generator.
provider.GenerateCodeFromCompileUnit(compileUnit, outWriter,
null);
// Close the output file.
outWriter.Close();
}
return(sourceFile);
}
static void Main(string[] args)
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace myNamespace = new CodeNamespace("MyNamespace");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass");
CodeEntryPointMethod start = new CodeEntryPointMethod();
CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World"));
compileUnit.Namespaces.Add(myNamespace);
myNamespace.Types.Add(myClass);
myClass.Members.Add(start);
start.Statements.Add(cs1);
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StreamWriter sw = new StreamWriter("HelloWorld.cs", false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
tw.Close();
}
Console.WriteLine("HelloWorld.cs generated in .../bin/Debug or .../bin/Release project folders.");
Console.Write("Press a key to exit");
Console.ReadKey();
}
private static Assembly GenerateAssembly(string asmxFile)
{
string strWsdl = WsdlFromUrl(GetApplicationPath() + "/" + asmxFile + "?wsdl");
// Xml text reader
StringReader wsdlStringReader = new StringReader(strWsdl);
XmlTextReader tr = new XmlTextReader(wsdlStringReader);
ServiceDescription sd = ServiceDescription.Read(tr);
tr.Close();
// WSDL service description importer
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespaceFluorine = new CodeNamespace("FluorineFx");
codeCompileUnit.Namespaces.Add(codeNamespaceFluorine);
CodeNamespace codeNamespace = new CodeNamespace(FluorineConfiguration.Instance.WsdlProxyNamespace);
codeCompileUnit.Namespaces.Add(codeNamespace);
#if (NET_1_1)
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
sdi.ProtocolName = "Soap";
sdi.Import(codeNamespace, codeCompileUnit);
CSharpCodeProvider provider = new CSharpCodeProvider();
#else
// Create a WSDL collection.
DiscoveryClientDocumentCollection wsdlCollection = new DiscoveryClientDocumentCollection();
wsdlCollection.Add(asmxFile, sd);
// Create a web refererence using the WSDL collection.
WebReference reference = new WebReference(wsdlCollection, codeNamespace);
reference.ProtocolName = "Soap12";
// Create a web reference collection.
WebReferenceCollection references = new WebReferenceCollection();
references.Add(reference);
WebReferenceOptions options = new WebReferenceOptions();
options.Style = ServiceDescriptionImportStyle.Client;
options.CodeGenerationOptions = CodeGenerationOptions.None;
options.SchemaImporterExtensions.Add(typeof(DataTableSchemaImporterExtension).AssemblyQualifiedName);
CSharpCodeProvider provider = new CSharpCodeProvider();
ServiceDescriptionImporter.GenerateWebReferences(references, provider, codeCompileUnit, options);
// Compile a proxy client
//provider.GenerateCodeFromCompileUnit(codeCompileUnit, Console.Out, new CodeGeneratorOptions());
#endif
//http://support.microsoft.com/default.aspx?scid=kb;en-us;326790
//http://pluralsight.com/wiki/default.aspx/Craig.RebuildingWsdlExe
if (!FluorineConfiguration.Instance.WsdlGenerateProxyClasses)
{
//Strip any code that isn't the proxy class itself.
foreach (CodeNamespace cns in codeCompileUnit.Namespaces)
{
// Remove anything that isn't the proxy itself
ArrayList typesToRemove = new ArrayList();
foreach (CodeTypeDeclaration codeType in cns.Types)
{
bool webDerived = false;
foreach (CodeTypeReference baseType in codeType.BaseTypes)
{
if (baseType.BaseType == "System.Web.Services.Protocols.SoapHttpClientProtocol")
{
webDerived = true;
break;
}
}
if (!webDerived)
typesToRemove.Add(codeType);
else
{
CodeAttributeDeclaration codeAttributeDeclaration = new CodeAttributeDeclaration(typeof(FluorineFx.RemotingServiceAttribute).FullName);
codeType.CustomAttributes.Add(codeAttributeDeclaration);
foreach (CodeTypeMember member in codeType.Members)
{
CodeConstructor ctor = member as CodeConstructor;
if (ctor != null)
{
// We got a constructor
// Add CookieContainer code
// this.CookieContainer = new System.Net.CookieContainer(); //Session Cookie
CodeSnippetStatement statement = new CodeSnippetStatement("this.CookieContainer = new System.Net.CookieContainer(); //Session Cookie");
ctor.Statements.Add(statement);
}
}
}
}
foreach (CodeTypeDeclaration codeType in typesToRemove)
{
codeNamespace.Types.Remove(codeType);
}
}
}
else
{
foreach (CodeNamespace cns in codeCompileUnit.Namespaces)
{
foreach (CodeTypeDeclaration codeType in cns.Types)
{
bool webDerived = false;
foreach (CodeTypeReference baseType in codeType.BaseTypes)
{
if (baseType.BaseType == "System.Web.Services.Protocols.SoapHttpClientProtocol")
{
webDerived = true;
break;
}
}
if (webDerived)
{
CodeAttributeDeclaration codeAttributeDeclaration = new CodeAttributeDeclaration(typeof(FluorineFx.RemotingServiceAttribute).FullName);
codeType.CustomAttributes.Add(codeAttributeDeclaration);
foreach (CodeTypeMember member in codeType.Members)
{
CodeConstructor ctor = member as CodeConstructor;
if (ctor != null)
{
// We got a constructor
// Add CookieContainer code
// this.CookieContainer = new System.Net.CookieContainer(); //Session Cookie
CodeSnippetStatement statement = new CodeSnippetStatement("this.CookieContainer = new System.Net.CookieContainer(); //Session Cookie");
ctor.Statements.Add(statement);
}
}
}
}
}
}
if (FluorineConfiguration.Instance.ImportNamespaces != null)
{
for (int i = 0; i < FluorineConfiguration.Instance.ImportNamespaces.Count; i++)
{
ImportNamespace importNamespace = FluorineConfiguration.Instance.ImportNamespaces[i];
codeNamespace.Imports.Add(new CodeNamespaceImport(importNamespace.Namespace));
}
}
// source code generation
StringBuilder srcStringBuilder = new StringBuilder();
StringWriter sw = new StringWriter(srcStringBuilder);
#if (NET_1_1)
ICodeGenerator icg = provider.CreateGenerator();
icg.GenerateCodeFromCompileUnit(codeCompileUnit, sw, null);
#else
provider.GenerateCodeFromCompileUnit(codeCompileUnit, sw, null);
#endif
string srcWSProxy = srcStringBuilder.ToString();
sw.Close();
// assembly compilation.
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
cp.ReferencedAssemblies.Add("System.Web.Services.dll");
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.GlobalAssemblyCache)
{
//Only System namespace
if (assembly.GetName().Name.StartsWith("System"))
{
if (!cp.ReferencedAssemblies.Contains(assembly.GetName().Name + ".dll"))
cp.ReferencedAssemblies.Add(assembly.Location);
}
}
else
{
if (assembly.GetName().Name.StartsWith("mscorlib"))
continue;
//if( assembly.Location.ToLower().StartsWith(System.Web.HttpRuntime.CodegenDir.ToLower()) )
// continue;
try
{
if (assembly.Location != null && assembly.Location != string.Empty)
cp.ReferencedAssemblies.Add(assembly.Location);
}
catch (NotSupportedException)
{
//NET2
}
}
}
cp.GenerateExecutable = false;
//http://support.microsoft.com/kb/815251
//http://support.microsoft.com/kb/872800
cp.GenerateInMemory = false;//true;
cp.IncludeDebugInformation = false;
#if (NET_1_1)
ICodeCompiler icc = provider.CreateCompiler();
CompilerResults cr = icc.CompileAssemblyFromSource(cp, srcWSProxy);
#else
CompilerResults cr = provider.CompileAssemblyFromSource(cp, srcWSProxy);
#endif
if (cr.Errors.Count > 0)
{
StringBuilder sbMessage = new StringBuilder();
sbMessage.Append(string.Format("Build failed: {0} errors", cr.Errors.Count));
if (log.IsErrorEnabled)
log.Error(__Res.GetString(__Res.Wsdl_ProxyGenFail));
foreach (CompilerError e in cr.Errors)
{
log.Error(__Res.GetString(__Res.Compiler_Error, e.Line, e.Column, e.ErrorText));
sbMessage.Append("\n");
sbMessage.Append(e.ErrorText);
}
StringBuilder sbSourceTrace = new StringBuilder();
sbSourceTrace.Append("Attempt to compile the generated source code:");
sbSourceTrace.Append(Environment.NewLine);
StringWriter swSourceTrace = new StringWriter(sbSourceTrace);
IndentedTextWriter itw = new IndentedTextWriter(swSourceTrace, " ");
provider.GenerateCodeFromCompileUnit(codeCompileUnit, itw, new CodeGeneratorOptions());
itw.Close();
log.Error(sbSourceTrace.ToString());
throw new FluorineException(sbMessage.ToString());
}
return cr.CompiledAssembly;
}
static void CompileLocations (string outputFile)
{
CodeCompileUnit unit = new CodeCompileUnit ();
CodeNamespace ns = new CodeNamespace ("Desklet.Weather");
unit.Namespaces.Add (ns);
ns.Imports.Add (new CodeNamespaceImport ("System"));
ns.Imports.Add (new CodeNamespaceImport ("System.Collections.Generic"));
MainClass = new CodeTypeDeclaration ("Locations");
MainClass.TypeAttributes = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public;
MainClass.IsPartial = true;
ns.Types.Add (MainClass);
CodeMemberMethod buildData = new CodeMemberMethod ();
buildData.Name = "BuildData";
GenerateBuildData (buildData);
MainClass.Members.Add (buildData);
CodeDomProvider provider = new CSharpCodeProvider ();
ICodeGenerator gen = provider.CreateGenerator ();
TextWriter tw = new IndentedTextWriter (new StreamWriter (outputFile, false), "\t");
gen.GenerateCodeFromCompileUnit (unit, tw, new CodeGeneratorOptions ());
tw.Close ();
}
