static void Main(string[] args)
{
foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
{
foreach (string lang in ci.GetLanguages())
{
Console.Write($"{lang} \t");
}
Console.WriteLine();
}
CodeNamespace progNamespace = HelloWorldCodeDOM.BuildProgram();
var compilerOptions = new CodeGeneratorOptions
{
IndentString = " ",
BracingStyle = "C",
BlankLinesBetweenMembers = false
};
AddMyClass(progNamespace);
var codeText = new StringBuilder();
using (var codeWriter = new StringWriter(codeText))
{
CodeDomProvider.CreateProvider("c#").GenerateCodeFromNamespace(progNamespace, codeWriter, compilerOptions);
}
var script = codeText.ToString();
Console.WriteLine(script);
}
private void ListSupportedLanguages()
{
// Loop through information about all compilers.
CompilerInfo[] compiler_infos =
CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo info in compiler_infos)
{
if (info.IsCodeDomProviderTypeValid)
{
// Get information about this compiler.
CodeDomProvider provider = info.CreateProvider();
//string extensions = "";
string default_extension = provider.FileExtension;
if (default_extension[0] != '.')
{
default_extension = '.' + default_extension;
}
string default_language =
CodeDomProvider.GetLanguageFromExtension(default_extension);
toolStripComboBoxLang.Items.Add(default_language);
}
}
if (toolStripComboBoxLang.Items.Count > 0)
{
toolStripComboBoxLang.SelectedIndex = 0;
}
}
private void SupportedLanguages()
{
CompilerInfo[] aCompilerInfo = CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo oCompilerInfo in aCompilerInfo)
{
foreach (string szLanguage in oCompilerInfo.GetLanguages())
{
MessageBox.Show(szLanguage);
}
}
if (!CodeDomProvider.IsDefinedLanguage("GW-BASIC"))
{
MessageBox.Show("GW-BASIC Not supported");
}
if (!CodeDomProvider.IsDefinedLanguage("CSharp"))
{
MessageBox.Show("CSharp Not supported");
}
if (!CodeDomProvider.IsDefinedExtension(".BAS"))
{
MessageBox.Show(".BAS Not supported");
}
if (!CodeDomProvider.IsDefinedExtension(".cs"))
{
MessageBox.Show(".cs Not supported");
}
}
private static void Main()
{
var integratedFeatures = CodeDomProvider.GetAllCompilerInfo()
.Aggregate(string.Empty, (current, compilerInfo) => current + GetCompilerInfo(compilerInfo));
Console.WriteLine(integratedFeatures);
}
private static void Usage()
{
Console.WriteLine(SR.GetString(SR.Usage, Environment.Version, CommonResStrings.CopyrightForCmdLine));
Console.WriteLine(SR.GetString(SR.ValidLanguages));
CompilerInfo[] compilerInfos = CodeDomProvider.GetAllCompilerInfo();
for (int i = 0; i < compilerInfos.Length; i++)
{
string[] languages = compilerInfos[i].GetLanguages();
if (i != 0)
{
Console.Write(", ");
}
for (int j = 0; j < languages.Length; j++)
{
if (j != 0)
{
Console.Write(", ");
}
Console.Write(languages[j]);
}
}
Console.WriteLine();
}
static void Main()
{
foreach (CompilerInfo ci in
CodeDomProvider.GetAllCompilerInfo())
{
StringBuilder output = new StringBuilder();
string language = ci.GetLanguages()[0];
output.AppendFormat("{0} features:\r\n", language);
try
{
CodeDomProvider provider = CodeDomProvider
.CreateProvider(language);
output.AppendFormat("CaseInsensitive = {0}\r\n",
provider.LanguageOptions.HasFlag(
LanguageOptions.CaseInsensitive));
foreach (GeneratorSupport supportableFeature
in Enum.GetValues(typeof(GeneratorSupport)))
{
output.AppendFormat("{0} = {1}\r\n",
supportableFeature,
provider.Supports(supportableFeature));
}
}
catch (Exception ex)
{
output.AppendFormat("{0} occurred while getting " +
"features for language {1} with the following " +
"message:\r\n\r\n'{2}'.\r\n", ex.GetType().Name,
language, ex.Message);
}
Console.WriteLine(output.ToString());
}
Console.ReadLine();
}
public void GetAllCompilerInfo_ReturnsMinimumOfCSharpAndVB()
{
Type[] compilerInfos = CodeDomProvider.GetAllCompilerInfo().Where(provider => provider.IsCodeDomProviderTypeValid).Select(provider => provider.CodeDomProviderType).ToArray();
Assert.True(compilerInfos.Length >= 2);
Assert.Contains(typeof(CSharpCodeProvider), compilerInfos);
Assert.Contains(typeof(VBCodeProvider), compilerInfos);
}
static void Main(string[] args)
{
foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
{
foreach (string lang in ci.GetLanguages())
{
System.Console.Write("{0} ", lang);
}
System.Console.WriteLine();
}
}
static void DisplayAllCompilerInfo()
{
// <Snippet8>
CompilerInfo [] allCompilerInfo = CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo info in allCompilerInfo)
{
String defaultLanguage;
String defaultExtension;
CodeDomProvider provider = info.CreateProvider();
// Display information about this configured provider.
Console.WriteLine("Language provider: {0}",
provider.ToString());
Console.WriteLine();
Console.WriteLine(" Supported file extension(s):");
foreach (String extension in info.GetExtensions())
{
Console.WriteLine(" {0}", extension);
}
defaultExtension = provider.FileExtension;
if (defaultExtension[0] != '.')
{
defaultExtension = "." + defaultExtension;
}
Console.WriteLine(" Default file extension: {0}",
defaultExtension);
Console.WriteLine();
Console.WriteLine(" Supported language(s):");
foreach (String language in info.GetLanguages())
{
Console.WriteLine(" {0}", language);
}
defaultLanguage = CodeDomProvider.GetLanguageFromExtension(defaultExtension);
Console.WriteLine(" Default language: {0}",
defaultLanguage);
Console.WriteLine();
// Get the compiler settings for this provider.
CompilerParameters langCompilerConfig = info.CreateDefaultCompilerParameters();
Console.WriteLine(" Compiler options: {0}",
langCompilerConfig.CompilerOptions);
Console.WriteLine(" Compiler warning level: {0}",
langCompilerConfig.WarningLevel);
Console.WriteLine();
}
// </Snippet8>
}
static void ShowInstalledLanguages()
{
foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
{
foreach (string language in ci.GetLanguages())
{
Console.Write(language + " \t");
}
Console.WriteLine();
}
}
public void TestMethod1()
{
CompilerInfo[] infos = CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo info in infos)
{
string[] strs = info.GetLanguages();
foreach (string str in strs)
{
Console.WriteLine(str);
}
}
}
static void Main(string[] args)
{
CompilerInfo[] aCompilerInfo = CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo oCompilerInfo in aCompilerInfo)
{
foreach (string szLanguage in oCompilerInfo.GetLanguages())
{
Console.Write(szLanguage + "\n");
}
}
}
private CodeDomProvider CreateCodeDomProvider(string language)
{
foreach (var compiler in CodeDomProvider.GetAllCompilerInfo( ))
{
foreach (var compilerLanguage in compiler.GetLanguages( ))
{
if (string.Equals(language, compilerLanguage, StringComparison.OrdinalIgnoreCase))
{
return(CodeDomProvider.CreateProvider(compilerLanguage));
}
}
}
Log.LogError($"Unable to find a CodeDomProvider for language { language }.");
return(null);
}
public void Defaults()
{
cdp = new CodeDomProviderTest(); // execute ctor not a full trust
Assert.AreEqual(String.Empty, cdp.FileExtension, "FileExtension");
Assert.AreEqual(LanguageOptions.None, cdp.LanguageOptions, "LanguageOptions");
Assert.IsNull(cdp.CreateCompiler(), "CreateCompiler");
Assert.IsNull(cdp.CreateGenerator(), "CreateGenerator");
Assert.IsNull(cdp.CreateGenerator(String.Empty), "CreateGenerator(string)");
Assert.IsNull(cdp.CreateGenerator(writer), "CreateGenerator(TextWriter)");
Assert.IsNull(cdp.CreateParser(), "CreateParser()");
Assert.IsNotNull(cdp.GetConverter(typeof(string)), "GetConverter");
Assert.IsNotNull(CodeDomProvider.GetAllCompilerInfo(), "GetAllCompilerInfo");
// mono returns null (missing config?)
CodeDomProvider.GetCompilerInfo("cs");
CodeDomProvider.GetLanguageFromExtension("cs");
Assert.IsFalse(CodeDomProvider.IsDefinedExtension(String.Empty), "String.Empty");
Assert.IsFalse(CodeDomProvider.IsDefinedLanguage(String.Empty), "String.Empty");
}
static void Main(String[] args)
{
CodeNamespace prgNameSpace = BuildProgram();
var compilerOptions = new CodeGeneratorOptions()
{
IndentString = " ",
BracingStyle = "C",
BlankLinesBetweenMembers = false
};
foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
{
var codeText = new StringBuilder();
String ln = ci.GetLanguages()[0];
using (var codeWriter = new StringWriter(codeText))
{
CodeDomProvider.CreateProvider(ln)
.GenerateCodeFromNamespace(prgNameSpace, codeWriter, compilerOptions);
}
Console.WriteLine("lang is " + ln);
Console.WriteLine(codeText.ToString());
Console.WriteLine();
}
}
internal static long GetRecompilationHash(CompilationSection ps)
{
HashCodeCombiner recompilationHash = new HashCodeCombiner();
AssemblyCollection assemblies;
BuildProviderCollection builders;
FolderLevelBuildProviderCollection buildProviders;
CodeSubDirectoriesCollection codeSubDirs;
// Combine items from Compilation section
recompilationHash.AddObject(ps.Debug);
recompilationHash.AddObject(ps.TargetFramework);
recompilationHash.AddObject(ps.Strict);
recompilationHash.AddObject(ps.Explicit);
recompilationHash.AddObject(ps.Batch);
recompilationHash.AddObject(ps.OptimizeCompilations);
recompilationHash.AddObject(ps.BatchTimeout);
recompilationHash.AddObject(ps.MaxBatchGeneratedFileSize);
recompilationHash.AddObject(ps.MaxBatchSize);
recompilationHash.AddObject(ps.NumRecompilesBeforeAppRestart);
recompilationHash.AddObject(ps.DefaultLanguage);
recompilationHash.AddObject(ps.UrlLinePragmas);
recompilationHash.AddObject(ps.DisableObsoleteWarnings);
if (ps.AssemblyPostProcessorTypeInternal != null)
{
recompilationHash.AddObject(ps.AssemblyPostProcessorTypeInternal.FullName);
}
if (!String.IsNullOrWhiteSpace(ps.ControlBuilderInterceptorType))
{
recompilationHash.AddObject(ps.ControlBuilderInterceptorType);
}
// Combine items from Compilers collection
foreach (Compiler compiler in ps.Compilers)
{
recompilationHash.AddObject(compiler.Language);
recompilationHash.AddObject(compiler.Extension);
recompilationHash.AddObject(compiler.Type);
recompilationHash.AddObject(compiler.WarningLevel);
recompilationHash.AddObject(compiler.CompilerOptions);
}
// Combine items from <expressionBuilders> section
foreach (System.Web.Configuration.ExpressionBuilder eb in ps.ExpressionBuilders)
{
recompilationHash.AddObject(eb.ExpressionPrefix);
recompilationHash.AddObject(eb.Type);
}
// Combine items from the Assembly collection
assemblies = ps.Assemblies;
if (assemblies.Count == 0)
{
recompilationHash.AddObject("__clearassemblies");
}
else
{
foreach (AssemblyInfo ai in assemblies)
{
recompilationHash.AddObject(ai.Assembly);
}
}
// Combine items from the Builders Collection
builders = ps.BuildProviders;
if (builders.Count == 0)
{
recompilationHash.AddObject("__clearbuildproviders");
}
else
{
foreach (System.Web.Configuration.BuildProvider bp in builders)
{
recompilationHash.AddObject(bp.Type);
recompilationHash.AddObject(bp.Extension);
}
}
// Combine items from the FolderLevelBuildProviderCollection
buildProviders = ps.FolderLevelBuildProviders;
if (buildProviders.Count == 0)
{
recompilationHash.AddObject("__clearfolderlevelbuildproviders");
}
else
{
foreach (System.Web.Configuration.FolderLevelBuildProvider bp in buildProviders)
{
recompilationHash.AddObject(bp.Type);
recompilationHash.AddObject(bp.Name);
}
}
codeSubDirs = ps.CodeSubDirectories;
if (codeSubDirs.Count == 0)
{
recompilationHash.AddObject("__clearcodesubdirs");
}
else
{
foreach (CodeSubDirectory csd in codeSubDirs)
{
recompilationHash.AddObject(csd.DirectoryName);
}
}
// Make sure the <system.CodeDom> section is hashed properly.
CompilerInfo[] compilerInfoArray = CodeDomProvider.GetAllCompilerInfo();
if (compilerInfoArray != null)
{
CompilerInfo cppCodeProvider = CodeDomProvider.GetCompilerInfo("cpp");
foreach (CompilerInfo info in compilerInfoArray)
{
// Skip cpp code provider (Dev11 193323).
if (info == cppCodeProvider)
{
continue;
}
// Ignore it if the type is not valid.
if (!info.IsCodeDomProviderTypeValid)
{
continue;
}
CompilerParameters parameters = info.CreateDefaultCompilerParameters();
string option = parameters.CompilerOptions;
if (!String.IsNullOrEmpty(option))
{
Type type = info.CodeDomProviderType;
if (type != null)
{
recompilationHash.AddObject(type.FullName);
}
// compilerOptions need to be hashed.
recompilationHash.AddObject(option);
}
// DevDiv 62998
// The tag providerOption needs to be added to the hash,
// as the user could switch between v2 and v3.5.
if (info.CodeDomProviderType == null)
{
continue;
}
// Add a hash for each providerOption added, specific for each codeDomProvider, so that
// if some codedom setting has changed, we know we have to recompile.
IDictionary <string, string> providerOptions = GetProviderOptions(info);
if (providerOptions != null && providerOptions.Count > 0)
{
string codeDomProviderType = info.CodeDomProviderType.FullName;
foreach (string key in providerOptions.Keys)
{
string value = providerOptions[key];
recompilationHash.AddObject(codeDomProviderType + ":" + key + "=" + value);
}
}
}
}
return(recompilationHash.CombinedHash);
}
internal static long GetRecompilationHash(CompilationSection ps)
{
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddObject(ps.Debug);
combiner.AddObject(ps.TargetFramework);
combiner.AddObject(ps.Strict);
combiner.AddObject(ps.Explicit);
combiner.AddObject(ps.Batch);
combiner.AddObject(ps.OptimizeCompilations);
combiner.AddObject(ps.BatchTimeout);
combiner.AddObject(ps.MaxBatchGeneratedFileSize);
combiner.AddObject(ps.MaxBatchSize);
combiner.AddObject(ps.NumRecompilesBeforeAppRestart);
combiner.AddObject(ps.DefaultLanguage);
combiner.AddObject(ps.UrlLinePragmas);
if (ps.AssemblyPostProcessorTypeInternal != null)
{
combiner.AddObject(ps.AssemblyPostProcessorTypeInternal.FullName);
}
foreach (Compiler compiler in ps.Compilers)
{
combiner.AddObject(compiler.Language);
combiner.AddObject(compiler.Extension);
combiner.AddObject(compiler.Type);
combiner.AddObject(compiler.WarningLevel);
combiner.AddObject(compiler.CompilerOptions);
}
foreach (System.Web.Configuration.ExpressionBuilder builder in ps.ExpressionBuilders)
{
combiner.AddObject(builder.ExpressionPrefix);
combiner.AddObject(builder.Type);
}
AssemblyCollection assemblies = ps.Assemblies;
if (assemblies.Count == 0)
{
combiner.AddObject("__clearassemblies");
}
else
{
foreach (AssemblyInfo info in assemblies)
{
combiner.AddObject(info.Assembly);
}
}
BuildProviderCollection buildProviders = ps.BuildProviders;
if (buildProviders.Count == 0)
{
combiner.AddObject("__clearbuildproviders");
}
else
{
foreach (System.Web.Configuration.BuildProvider provider in buildProviders)
{
combiner.AddObject(provider.Type);
combiner.AddObject(provider.Extension);
}
}
FolderLevelBuildProviderCollection folderLevelBuildProviders = ps.FolderLevelBuildProviders;
if (folderLevelBuildProviders.Count == 0)
{
combiner.AddObject("__clearfolderlevelbuildproviders");
}
else
{
foreach (FolderLevelBuildProvider provider2 in folderLevelBuildProviders)
{
combiner.AddObject(provider2.Type);
combiner.AddObject(provider2.Name);
}
}
CodeSubDirectoriesCollection codeSubDirectories = ps.CodeSubDirectories;
if (codeSubDirectories.Count == 0)
{
combiner.AddObject("__clearcodesubdirs");
}
else
{
foreach (CodeSubDirectory directory in codeSubDirectories)
{
combiner.AddObject(directory.DirectoryName);
}
}
CompilerInfo[] allCompilerInfo = CodeDomProvider.GetAllCompilerInfo();
if (allCompilerInfo != null)
{
foreach (CompilerInfo info2 in allCompilerInfo)
{
if (info2.IsCodeDomProviderTypeValid)
{
string compilerOptions = info2.CreateDefaultCompilerParameters().CompilerOptions;
if (!string.IsNullOrEmpty(compilerOptions))
{
Type codeDomProviderType = info2.CodeDomProviderType;
if (codeDomProviderType != null)
{
combiner.AddObject(codeDomProviderType.FullName);
}
combiner.AddObject(compilerOptions);
}
if (info2.CodeDomProviderType != null)
{
IDictionary <string, string> providerOptions = GetProviderOptions(info2);
if ((providerOptions != null) && (providerOptions.Count > 0))
{
string fullName = info2.CodeDomProviderType.FullName;
foreach (string str3 in providerOptions.Keys)
{
string str4 = providerOptions[str3];
combiner.AddObject(fullName + ":" + str3 + "=" + str4);
}
}
}
}
}
}
return(combiner.CombinedHash);
}