| private CreateGenerator ( ) : ICodeGenerator | ||
| Résultat | ICodeGenerator | |
public static string Generate (string inputFileContent, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeDomProvider codeProvider)
{
var dataSet = new DataSet ();
dataSet.ReadXmlSchema (inputFileContent);
T.Generate (dataSet, mainNamespace, codeProvider.CreateGenerator ());
return null;
}
protected bool Supports (CodeDomProvider provider, GeneratorSupport support) {
#if WHIDBEY
return provider.Supports (support);
#else
return (provider.CreateGenerator ()).Supports (support);
#endif
}
internal string GenerateTypedDataSet(XmlSchemaElement element, XmlSchemas schemas, CodeNamespace codeNamespace, StringCollection references, CodeDomProvider codeProvider)
{
if (element == null)
{
return null;
}
if (this.importedTypes[element.SchemaType] != null)
{
return (string) this.importedTypes[element.SchemaType];
}
IList list = schemas.GetSchemas(element.QualifiedName.Namespace);
if (list.Count != 1)
{
return null;
}
XmlSchema schema = list[0] as XmlSchema;
if (schema == null)
{
return null;
}
DataSet dataSet = new DataSet();
using (MemoryStream stream = new MemoryStream())
{
schema.Write(stream);
stream.Position = 0L;
dataSet.ReadXmlSchema(stream);
}
string name = new TypedDataSetGenerator().GenerateCode(dataSet, codeNamespace, codeProvider.CreateGenerator()).Name;
this.importedTypes.Add(element.SchemaType, name);
references.Add("System.Data.dll");
return name;
}
public void InitBase()
{
provider = new CSharpCodeProvider ();
generator = provider.CreateGenerator ();
options = new CodeGeneratorOptions ();
writer = new StringWriter ();
writer.NewLine = "\n";
}
private static void GenerateViaCodeDOM(string outputFileName, System.CodeDom.Compiler.CodeDomProvider provider, System.CodeDom.CodeCompileUnit compileUnit)
{
System.CodeDom.Compiler.ICodeGenerator gen = provider.CreateGenerator();
System.CodeDom.Compiler.IndentedTextWriter tw;
tw = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFileName, false), " ");
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
gen.GenerateCodeFromCompileUnit(compileUnit, tw, options);
tw.Flush();
tw.Close();
}
public static string ToCode(CodeCompileUnit compileunit, CodeDomProvider provider)
{
StringBuilder sb = new StringBuilder() ;
StringWriter sw = new StringWriter(sb);
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
ICodeGenerator gen = provider.CreateGenerator(tw);
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
string code = sb.ToString();
return code;
}
public static void GenerateCode(string fileName,
System.CodeDom.Compiler.CodeDomProvider provider,
System.CodeDom.CodeCompileUnit compileUnit)
{
System.CodeDom.Compiler.ICodeGenerator gen = provider.CreateGenerator();
System.CodeDom.Compiler.IndentedTextWriter tw = null;
try
{
tw = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(fileName, false), " ");
gen.GenerateCodeFromCompileUnit(compileUnit, tw, new System.CodeDom.Compiler.CodeGeneratorOptions());
}
finally
{
if (tw != null)
{
tw.Flush();
tw.Close();
}
}
}
public static void GenerateProjectCode(string file, CodeDomProvider provider, GenerationOptions options, ProjectBackend[] projects)
{
CodeGenerationResult res = GenerateProjectCode (options, projects);
ICodeGenerator gen = provider.CreateGenerator ();
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 {
gen.GenerateCodeFromCompileUnit (unit, fileStream, new CodeGeneratorOptions ());
} finally {
fileStream.Close ();
}
}
}
public String ToCode(CodeCompileUnit compileunit, CodeDomProvider provider, IDomainMap domainMap)
{
StringBuilder sb = new StringBuilder() ;
StringWriter sw = new StringWriter(sb);
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
ICodeGenerator gen = provider.CreateGenerator(tw);
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
string code = sb.ToString();
if (domainMap != null)
{
foreach (ICodeMap codeMap in domainMap.CodeMaps)
{
if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp)
{
code = GetDomainCodeMap(domainMap, codeMap) + code;
}
else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB)
{
code = GetDomainCodeMap(domainMap, codeMap) + code;
}
// if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi)
// {
// code = GetDomainCodeMap(code, classMap, codeMap) + code;
// }
}
foreach (IClassMap classMap in domainMap.ClassMaps)
{
foreach (ICodeMap codeMap in classMap.CodeMaps)
{
if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp)
{
code = InsertCodeMap(code, classMap, codeMap);
}
else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB)
{
code = InsertCodeMap(code, classMap, codeMap);
}
// if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi)
// {
// code = InsertCodeMap(code, classMap, codeMap);
// }
}
}
}
return code;
}
/// <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;
}
public CompilerInfo(CodeDomProvider provider)
{
Compiler = provider.CreateCompiler();
CodeGen = provider.CreateGenerator();
}
private void GenerateTestCase(CodeDomProvider provider, string extension, string ns, string name, string area,
string[] actions, TextWriter output)
{
CodeNamespace nsunit = GenerateControllerTestCode(ns, name, area, actions);
FileInfo controllerFile = new FileInfo(
Path.Combine(testsDir.FullName, name + "Tests" + extension) );
if (!controllerFile.Exists)
{
using (StreamWriter sw = new StreamWriter(controllerFile.FullName, false, Encoding.Default))
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
#if DOTNET2
provider.GenerateCodeFromNamespace(nsunit, sw, opts);
#else
provider.CreateGenerator().GenerateCodeFromNamespace(nsunit, sw, opts);
#endif
}
}
else
{
output.WriteLine("Skipping {0} as the files exists", controllerFile.FullName);
}
}
public static string Run(CodeWizard codeWizard, IServiceProvider serviceProvider, CodeDomProvider codeDomProvider, QueryBuilderType type)
{
IUIService service = (IUIService) serviceProvider.GetService(typeof(IUIService));
IDatabaseManager manager = (IDatabaseManager) serviceProvider.GetService(typeof(IDatabaseManager));
if (codeDomProvider != null)
{
ICodeGenerator generator = codeDomProvider.CreateGenerator();
if (generator != null)
{
QueryBuilder form = new QueryBuilder(codeWizard, type);
if (service.ShowDialog(form) == DialogResult.OK)
{
StringWriter w = new StringWriter();
CodeGeneratorOptions o = new CodeGeneratorOptions();
CodeMemberMethod method = new CodeMemberMethod();
method.Name = form.MethodName;
IDictionary dictionary = new HybridDictionary(true);
foreach (QueryParameter parameter in form.Parameters)
{
string variableNameFromParameterName = GetVariableNameFromParameterName(parameter.Name);
if (dictionary[variableNameFromParameterName] == null)
{
System.Type typeFromDbType = QueryParameter.GetTypeFromDbType(parameter.Type);
method.Parameters.Add(new CodeParameterDeclarationExpression(typeFromDbType, variableNameFromParameterName));
dictionary[variableNameFromParameterName] = string.Empty;
}
}
method.ReturnType = new CodeTypeReference(form.ReturnType);
method.Attributes = MemberAttributes.Final;
method.Statements.AddRange(BuildConnection((IDataProviderDatabase) form.Database, ((IDataProviderDatabase) form.Database).ConnectionString));
method.Statements.Add(new CodeSnippetStatement(string.Empty));
method.Statements.Add(BuildQueryString(form.Query));
method.Statements.AddRange(BuildCommand((IDataProviderDatabase) form.Database));
method.Statements.Add(new CodeSnippetStatement(string.Empty));
int num = 0;
dictionary = new HybridDictionary(true);
foreach (QueryParameter parameter2 in form.Parameters)
{
string str2 = GetVariableNameFromParameterName(parameter2.Name);
if (dictionary[str2] == null)
{
method.Statements.AddRange(BuildDbParameterAssignment((IDataProviderDatabase) form.Database, parameter2.Name, parameter2.Type, codeDomProvider));
num++;
dictionary[str2] = string.Empty;
}
}
if (num > 0)
{
method.Statements.Add(new CodeSnippetStatement(string.Empty));
}
if (type == QueryBuilderType.Select)
{
if (form.ReturnType == typeof(IDataReader))
{
method.Statements.AddRange(BuildSelectReturnDataReader());
}
else
{
method.Statements.AddRange(BuildSelectReturnDataSet((IDataProviderDatabase) form.Database));
}
}
else
{
method.Statements.AddRange(BuildExecuteNonQuery());
}
CodeTypeDeclaration e = new CodeTypeDeclaration("TempType");
e.Members.Add(method);
generator.GenerateCodeFromType(e, w, o);
string s = w.ToString();
w = new StringWriter();
CodeTypeDeclaration declaration2 = new CodeTypeDeclaration("TempType");
generator.GenerateCodeFromType(declaration2, w, o);
string str4 = w.ToString();
w = new StringWriter();
StringReader reader = new StringReader(s);
StringReader reader2 = new StringReader(str4);
string str5 = reader.ReadLine();
string str6 = reader2.ReadLine();
while (str5 != null)
{
if (str5 != str6)
{
w.WriteLine(str5);
}
else
{
str6 = reader2.ReadLine();
}
str5 = reader.ReadLine();
}
return w.ToString();
}
}
}
return string.Empty;
}
internal string GenerateTypedDataSet(XmlSchemaElement element, XmlSchemas schemas, CodeNamespace codeNamespace, StringCollection references, CodeDomProvider codeProvider) {
if (element == null)
return null;
if (importedTypes[element.SchemaType] != null)
return (string)importedTypes[element.SchemaType];
IList values = schemas.GetSchemas(element.QualifiedName.Namespace);
if (values.Count != 1) {
return null;
}
XmlSchema schema = values[0] as XmlSchema;
if (schema == null)
return null;
DataSet ds = new DataSet();
//
using (MemoryStream stream = new MemoryStream()) {
schema.Write(stream);
stream.Position = 0;
ds.ReadXmlSchema(stream);
}
#pragma warning disable 618 // ignore obsolete warning about TypedDataSetGenerator
CodeTypeDeclaration dsClass = new TypedDataSetGenerator().GenerateCode(ds, codeNamespace, codeProvider.CreateGenerator());
#pragma warning restore 618
string typeName = dsClass.Name;
importedTypes.Add(element.SchemaType, typeName);
references.Add("System.Data.dll");
return typeName;
}
private void CreateCodeGenerator(out ICodeGenerator codeGen, out string fileExtension)
{
Language language1 = WsdlProperties.Language;
switch (language1)
{
case Language.CS:
codeProvider = new CSharpCodeProvider();
break;
case Language.VB:
codeProvider = new VBCodeProvider();
break;
default:
{
if (language1 != Language.Custom)
{
throw new Exception("Unknown language");
}
Type type1 = Type.GetType(WsdlProperties.CustomCodeDomProvider);
if (type1 == null)
{
throw new TypeLoadException("Type '" + WsdlProperties.CustomCodeDomProvider +
"' is not found");
}
codeProvider = (CodeDomProvider) Activator.CreateInstance(type1);
break;
}
}
if (codeProvider != null)
{
codeGen = codeProvider.CreateGenerator();
fileExtension = codeProvider.FileExtension;
if (fileExtension == null)
{
fileExtension = string.Empty;
}
else if ((fileExtension.Length > 0) && (fileExtension[0] != '.'))
{
fileExtension = "." + fileExtension;
}
}
else
{
fileExtension = ".src";
codeGen = null;
}
}
public static string Generate (DataSet dataSet, CodeNamespace codeNamespace, CodeDomProvider codeProvider)
{
T.Generate (dataSet, codeNamespace, codeProvider.CreateGenerator ());
return null;
}
public String ToCodeFile(CodeCompileUnit compileunit, CodeDomProvider provider, string fileName)
{
#if NET2
String sourceFile;
if (provider.FileExtension[0] == '.')
sourceFile = fileName + provider.FileExtension;
else
sourceFile = fileName + "." + provider.FileExtension;
IndentedTextWriter tw = new IndentedTextWriter(
new StreamWriter(sourceFile, false), " ");
provider.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
tw.Close();
return sourceFile;
#else
ICodeGenerator gen = provider.CreateGenerator();
String sourceFile;
if (provider.FileExtension[0] == '.')
sourceFile = fileName + provider.FileExtension;
else
sourceFile = fileName + "." + provider.FileExtension;
IndentedTextWriter tw = new IndentedTextWriter(
new StreamWriter(sourceFile, false), " ");
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
tw.Close();
return sourceFile;
#endif
}
public CodeGenerationResult GenerateProjectCode(string file, string namespaceName, CodeDomProvider provider, GenerationOptions options, params Project[] projects)
{
ArrayList files = new ArrayList ();
CodeGenerationResult res = GenerateProjectCode (options, projects);
ICodeGenerator gen = provider.CreateGenerator ();
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 {
gen.GenerateCodeFromCompileUnit (unit, fileStream, new CodeGeneratorOptions ());
} finally {
fileStream.Close ();
}
}
return res;
}
public void InitBase()
{
provider = new CSharpCodeProvider ();
generator = provider.CreateGenerator ();
options = new CodeGeneratorOptions ();
}
private void WriteClassFile(Project project, String name, CodeNamespace ns, CodeDomProvider provider)
{
String filename = String.Format("{0}.{1}", name, provider.FileExtension);
FileInfo fileInfo = new FileInfo( Path.Combine(project.LastOutDir, filename) );
if (fileInfo.Exists && !project.OverwriteFiles)
{
Log( String.Format("Skipping {0} as it already exists", filename) );
}
else
{
Log( String.Format("Writing {0}...", filename) );
try
{
using(FileStream stream = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write))
{
StreamWriter writer = new StreamWriter(stream);
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
opts.BlankLinesBetweenMembers = true;
provider.CreateGenerator().GenerateCodeFromNamespace(ns, writer, opts);
writer.Flush();
writer.Close();
}
}
catch(Exception ex)
{
Log( String.Format("Error Writing {0} []", filename, ex.Message) );
}
}
}
