/// <summary> /// Create the converter in source code /// </summary> /// <param name="lang">C# or Visual Basic</param> /// <returns>Converter attribute in appropriate language</returns> internal string GetConverterCode(NetLanguage lang) { var sb = new StringBuilder(); if (mKind != ConverterKind.None) sb.Append("FieldConverter(ConverterKind." + mKind.ToString()); else if (mTypeName != string.Empty) { if (lang == NetLanguage.CSharp) sb.Append("FieldConverter(typeof(" + mTypeName + ")"); else if (lang == NetLanguage.VbNet) sb.Append("FieldConverter(GetType(" + mTypeName + ")"); } else return string.Empty; if (!string.IsNullOrEmpty(mArg1)) { sb.Append(", \"" + mArg1 + "\""); if (!string.IsNullOrEmpty(mArg2)) { sb.Append(", \"" + mArg2 + "\""); if (!string.IsNullOrEmpty(mArg3)) { sb.Append(", \"" + mArg3 + "\""); } } } sb.Append(")"); return sb.ToString(); }
/// <summary>Write the ENCRYPTED source code of the current class to a file. (In C#)</summary> /// <param name="filename">The file to write to.</param> /// <param name="lang">The .NET Language used to write the source code.</param> public void SaveToBinaryFile(string filename, NetLanguage lang) { var writer = new StreamWriter(filename); writer.Write(GetClassBinaryCode(lang)); writer.Close(); }
/// <summary> /// Create a class from a encrypted source file with the default password /// </summary> /// <param name="filename">The filename with the source of the class.</param> /// <param name="lang">The language used to compile the class.</param> /// <param name="className">The name of the class to return.</param> /// <returns>The compiled class.</returns> public static Type ClassFromBinaryFile(string filename, string className, NetLanguage lang) { return(ClassFromBinaryFile(filename, className, lang, "withthefilehelpers1.0.0youcancodewithoutproblems1.5.0")); }
//private NetVisibility mClassVisibility = NetVisibility.Public; //public NetVisibility ClassVisibility //{ // get { return mClassVisibility; } // set { mClassVisibility = value; } //} public string WizardOutput(NetLanguage lang) { if (mClassBuilder == null) return string.Empty; return mClassBuilder.GetClassSourceCode(lang); }
/// <summary> /// Add the namespace to the class details /// </summary> /// <param name="lang">Language type we are generating</param> /// <param name="sb">class text</param> private void BeginNamespace(NetLanguage lang, StringBuilder sb) { if (mNamespace == string.Empty) { return; } switch (lang) { case NetLanguage.CSharp: sb.Append("namespace "); sb.Append(mNamespace); sb.Append(StringHelper.NewLine); sb.Append("{"); break; case NetLanguage.VbNet: sb.Append("Namespace "); sb.Append(mNamespace); sb.Append(StringHelper.NewLine); break; } sb.Append(StringHelper.NewLine); }
private static string GetDelimiter(string delimiter, NetLanguage lang) { switch (lang) { case NetLanguage.CSharp: if (delimiter == "\t") { return("\"\\t\""); } else { return("\"" + delimiter + "\""); } case NetLanguage.VbNet: if (delimiter == "\t") { return("VbTab"); } else { return("\"" + delimiter + "\""); } default: throw new ArgumentOutOfRangeException(nameof(lang)); } }
/// <summary>Write the source code of the current class to a file. (In the especified language)</summary> /// <param name="filename">The file to write to.</param> /// <param name="lang">The .NET Language used to write the source code.</param> public void SaveToSourceFile(string filename, NetLanguage lang) { StreamWriter writer = new StreamWriter(filename); writer.Write(GetClassSourceCode(lang)); writer.Close(); }
public static string GetVisibility(NetLanguage leng, NetVisibility visi) { switch (leng) { case NetLanguage.VbNet: switch (visi) { case NetVisibility.Private: return "Private"; case NetVisibility.Protected: return "Protected"; case NetVisibility.Public: return "Public"; case NetVisibility.Internal: return "Friend"; } break; case NetLanguage.CSharp: switch (visi) { case NetVisibility.Private: return "private"; case NetVisibility.Protected: return "protected"; case NetVisibility.Public: return "public"; case NetVisibility.Internal: return "internal"; } break; default: break; } return ""; }
internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage leng) { if (mFieldQuoted == true) { if (leng == NetLanguage.CSharp) { string quoteStr = mQuoteChar.ToString(); if (mQuoteChar == '\'') { quoteStr = @"\'"; } attbs.AddAttribute("FieldQuoted('" + quoteStr + "', QuoteMode." + mQuoteMode.ToString() + ", MultilineMode." + mQuoteMultiline.ToString() + ")"); } else if (leng == NetLanguage.VbNet) { string quoteStr = mQuoteChar.ToString(); if (mQuoteChar == '"') { quoteStr = "\"\""; } attbs.AddAttribute("FieldQuoted(\"" + quoteStr + "\"c, QuoteMode." + mQuoteMode.ToString() + ", MultilineMode." + mQuoteMultiline.ToString() + ")"); } } }
private void AddAttributesInternal(AttributesBuilder attbs, NetLanguage lang) { if (mIgnoreFirstLines != 0) { attbs.AddAttribute("IgnoreFirst(" + mIgnoreFirstLines.ToString() + ")"); } if (mIgnoreLastLines != 0) { attbs.AddAttribute("IgnoreLast(" + mIgnoreLastLines.ToString() + ")"); } if (mIgnoreEmptyLines == true) { attbs.AddAttribute("IgnoreEmptyLines()"); } if (mRecordConditionInfo.Condition != FileHelpers.RecordCondition.None) { attbs.AddAttribute("ConditionalRecord(RecordCondition." + mRecordConditionInfo.Condition.ToString() + ", \"" + mRecordConditionInfo.Selector + "\")"); } if (mIgnoreCommentInfo.CommentMarker != null && mIgnoreCommentInfo.CommentMarker.Length > 0) { attbs.AddAttribute("IgnoreCommentedLines(\"" + mIgnoreCommentInfo.CommentMarker + "\", " + mIgnoreCommentInfo.InAnyPlace.ToString().ToLower() + ")"); } }
/// <summary> /// Add attributes to the field at the appropriate spot in the code /// </summary> /// <param name="attbs">Add attributes to this</param> /// <param name="lang">Language to use, C# of Visual Basic</param> internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage lang) { if (mFieldLength <= 0) { throw new BadUsageException("The Length of each field must be grater than 0"); } else { attbs.AddAttribute("FieldFixedLength(" + mFieldLength.ToString() + ")"); } if (mAlignMode != AlignMode.Left) { if (lang == NetLanguage.CSharp) { attbs.AddAttribute("FieldAlign(AlignMode." + mAlignMode.ToString() + ", '" + mAlignChar.ToString() + "')"); } else if (lang == NetLanguage.VbNet) { attbs.AddAttribute("FieldAlign(AlignMode." + mAlignMode.ToString() + ", \"" + mAlignChar.ToString() + "\"c)"); } } }
/// <summary> /// Create a class from a source file. /// </summary> /// <param name="filename">The filename with the source of the class.</param> /// <param name="className">The name of the class to return.</param> /// <param name="lang">The language used to compile the class.</param> /// <returns>The compiled class.</returns> public static Type ClassFromSourceFile(string filename, string className, NetLanguage lang) { var reader = new StreamReader(filename); string classDef = reader.ReadToEnd(); reader.Close(); return(ClassFromString(classDef, className, lang)); }
/// <summary>Compiles the source code passed and returns the Type with the name className.</summary> /// <param name="classStr">The Source Code of the class in the specified language</param> /// <param name="className">The Name of the Type that must be returned</param> /// <returns>The Type generated by runtime compilation of the class source.</returns> /// <param name="lang">One of the .NET Languages</param> public static Type ClassFromString(string classStr, string className, NetLanguage lang) { var cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("system.dll"); cp.ReferencedAssemblies.Add("system.data.dll"); cp.ReferencedAssemblies.Add(typeof (ClassBuilder).Assembly.GetModules()[0].FullyQualifiedName); cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.IncludeDebugInformation = false; var code = new StringBuilder(); switch (lang) { case NetLanguage.CSharp: code.Append("using System; using Transformalize.Libs.FileHelpers.Attributes; using Transformalize.Libs.FileHelpers.Enums; using System.Data; "); break; case NetLanguage.VbNet: code.Append("Imports System \n"); code.Append("Imports FileHelpers \n"); code.Append("Imports System.Data \n"); break; } code.Append(classStr); var comp = new CSharpCodeProvider(); var cr = comp.CompileAssemblyFromSource(cp, code.ToString()); if (cr.Errors.HasErrors) { var error = new StringBuilder(); error.Append("Error Compiling Expression: " + StringHelper.NewLine); foreach (CompilerError err in cr.Errors) { error.AppendFormat("Line {0}: {1}\n", err.Line, err.ErrorText); } throw new RunTimeCompilationException(error.ToString(), classStr, cr.Errors); } // Assembly.Load(cr.CompiledAssembly.); if (className != string.Empty) return cr.CompiledAssembly.GetType(className, true, true); else { var ts = cr.CompiledAssembly.GetTypes(); if (ts.Length > 0) foreach (var t in ts) { if (t.FullName.StartsWith("My.My") == false) return t; } throw new BadUsageException("The Compiled assembly don´t have any Type inside."); } }
private void AddAttributesInternal(AttributesBuilder attbs, NetLanguage leng) { if (mFieldOptional) { attbs.AddAttribute("FieldOptional()"); } if (mFieldIgnored) { attbs.AddAttribute("FieldIgnored()"); } if (mFieldInNewLine) { attbs.AddAttribute("FieldInNewLine()"); } if (mFieldNullValue != null) { if (mFieldNullValue is string) { attbs.AddAttribute("FieldNullValue(\"" + mFieldNullValue + "\")"); } else { var t = mFieldNullValue.GetType().FullName; var gt = string.Empty; if (leng == NetLanguage.CSharp) { gt = "typeof(" + t + ")"; } else if (leng == NetLanguage.VbNet) { gt = "GetType(" + t + ")"; } attbs.AddAttribute("FieldNullValue(" + gt + ", \"" + mFieldNullValue + "\")"); } } attbs.AddAttribute(mConverter.GetConverterCode(leng)); if (mTrimMode != TrimMode.None) { if (" \t" == mTrimChars) { attbs.AddAttribute("FieldTrim(TrimMode." + mTrimMode.ToString() + ")"); } else { attbs.AddAttribute("FieldTrim(TrimMode." + mTrimMode.ToString() + ", \"" + mTrimChars + "\")"); } } }
/// <summary> /// Returns the source code for the current class in the specified language. /// </summary> /// <param name="lang">The language for the return code.</param> /// <returns>The Source Code for the class that are currently building.</returns> public string GetClassSourceCode(NetLanguage lang) { ValidateClass(); var sb = new StringBuilder(100); BeginNamespace(lang, sb); var attbs = new AttributesBuilder(lang); AddAttributesInternal(attbs); AddAttributesCode(attbs, lang); sb.Append(attbs.GetAttributesCode()); switch (lang) { case NetLanguage.VbNet: sb.Append(GetVisibility(lang, mVisibility) + GetSealed(lang) + "Class " + mClassName); sb.Append(StringHelper.NewLine); break; case NetLanguage.CSharp: sb.Append(GetVisibility(lang, mVisibility) + GetSealed(lang) + "class " + mClassName); sb.Append(StringHelper.NewLine); sb.Append("{"); break; } sb.Append(StringHelper.NewLine); sb.Append(StringHelper.NewLine); foreach (FieldBuilder field in mFields) { sb.Append(field.GetFieldCode(lang)); sb.Append(StringHelper.NewLine); } sb.Append(StringHelper.NewLine); switch (lang) { case NetLanguage.VbNet: sb.Append("End Class"); break; case NetLanguage.CSharp: sb.Append("}"); break; } EndNamespace(lang, sb); return(sb.ToString()); }
public frmDataPreview(string data, NetLanguage language) { InitializeComponent(); ShowCode(data, language); //sdClassOut.Text = data; cboClassLanguage.Items.Clear(); cboClassLanguage.Items.AddRange(NetLanguageList.Languages.ToArray()); NetLanguageList.LanguageType selected = NetLanguageList.Languages.Find(x => x.Language == language); cboClassLanguage.SelectedItem = selected; }
/// <summary> /// Create a class from a encrypted source file with the given password /// </summary> /// <remarks>Edited by: Shreyas Narasimhan (17 March 2010)</remarks> /// <param name="filename">The filename with the source of the class.</param> /// <param name="className">The name of the class to return.</param> /// <param name="lang">The language used to compile the class.</param> /// <param name="password">The password used to decrypt the file</param> /// <returns></returns> public static Type ClassFromBinaryFile(string filename, string className, NetLanguage lang, string password) { var reader = new StreamReader(filename); string classDef = reader.ReadToEnd(); reader.Close(); classDef = Decrypt(classDef, password); return(ClassFromString(classDef, className, lang)); }
/// <summary> /// Add any attributes to source (currently only the delimiter attribute) /// </summary> /// <param name="attbs">Attributes storage area to add to class</param> /// <param name="lang"></param> internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage lang) { if (mDelimiter == string.Empty) { throw new BadUsageException("The Delimiter of the DelimiterClassBuilder can't be null or empty."); } else { attbs.AddAttribute("DelimitedRecord(" + GetDelimiter(mDelimiter, lang) + ")"); } }
/// <summary> /// Create a class from a encripted source file. /// </summary> /// <param name="filename">The filename with the source of the class.</param> /// <param name="lang">The languaje used to compile the class.</param> /// <param name="className">The name of the class to return.</param> /// <returns>The compiled class.</returns> public static Type ClassFromBinaryFile(string filename, string className, NetLanguage lang) { StreamReader reader = new StreamReader(filename); string classDef = reader.ReadToEnd(); reader.Close(); classDef = Decrypt(classDef, "withthefilehelpers1.0.0youcancodewithoutproblems1.5.0"); return(ClassFromString(classDef, className, lang)); }
public frmDataPreview(string data, NetLanguage language) { InitializeComponent(); ShowCode(data, language); //sdClassOut.Text = data; cboClassLanguage.Items.Clear(); cboClassLanguage.Items.Add(NetLanguage.CSharp); cboClassLanguage.Items.Add(NetLanguage.VbNet); cboClassLanguage.SelectedItem = language; }
/// <summary> /// Change the selected language /// </summary> protected override void OnSelectedIndexChanged(EventArgs e) { base.OnSelectedIndexChanged(e); var value = (LanguageType)this.SelectedItem; if (Language != value.Language) { Language = value.Language; if (LanguageChange != null) { LanguageChange(this, new EventLanguage(this.Language)); } } }
private void LanguageSelector_LanguageChange(object sender, LanguageSelector.EventLanguage e) { foreach (var item in this.Items) { this.Language = e.Language; LanguageType lang = item as LanguageType; if (lang.Language == e.Language) { this.SelectedItem = lang; return; } this.SelectedIndex = 0; } }
public static string SelectMode(int?languageId) { if (NetLanguage.GetcSharp().Id == languageId) { return(CsharpMode); } if (NetLanguage.GetVbNet().Id == languageId) { return(VbMode); } return(VbsMode); }
//private NetVisibility mClassVisibility = NetVisibility.Public; //public NetVisibility ClassVisibility //{ // get { return mClassVisibility; } // set { mClassVisibility = value; } //} public string WizardOutput(NetLanguage lang) { if (mClassBuilder == null) return string.Empty; try { return mClassBuilder.GetClassSourceCode(lang); } catch (Exception ex) { //MessageBox.Show(ex.Message, "Error generating class code", MessageBoxButtons.OK, MessageBoxIcon.Error); return ex.Message; } }
/// <summary> /// Add attributes to the field at the appropriate spot in the code /// </summary> /// <param name="attbs">Add attributes to this</param> /// <param name="lang">Language to use, C# of Visual Basic</param> internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage lang) { if (mFieldLength <= 0) throw new BadUsageException("The Length of each field must be grater than 0"); else attbs.AddAttribute("FieldFixedLength("+ mFieldLength.ToString() +")"); if (mAlignMode != AlignMode.Left) { if (lang == NetLanguage.CSharp) attbs.AddAttribute("FieldAlign(AlignMode."+ mAlignMode.ToString()+", '"+ mAlignChar.ToString() +"')"); else if (lang == NetLanguage.VbNet) attbs.AddAttribute("FieldAlign(AlignMode."+ mAlignMode.ToString()+", \""+ mAlignChar.ToString() +"\"c)"); } }
private static string GetLangPrefix(int?langId) { var netLanguagePrefix = string.Empty; if (langId == NetLanguage.GetcSharp().Id) { netLanguagePrefix = "cs"; } else if (langId == NetLanguage.GetVbNet().Id) { netLanguagePrefix = "vb"; } return(netLanguagePrefix); }
public string WizardOutput(NetLanguage lang) { if (mClassBuilder == null) { return(string.Empty); } try { return(mClassBuilder.GetClassSourceCode(lang)); } catch (Exception ex) { //MessageBox.Show(ex.Message, "Error generating class code", MessageBoxButtons.OK, MessageBoxIcon.Error); return(ex.Message); } }
private void ShowCode(string code, NetLanguage language) { mLastCode = code; browserCode.DocumentText = ""; var colorizer = new CodeColorizer(); switch (language) { case NetLanguage.CSharp: browserCode.DocumentText = GetDefaultCss() + colorizer.Colorize(code, Languages.CSharp); break; case NetLanguage.VbNet: browserCode.DocumentText = GetDefaultCss() + colorizer.Colorize(code, Languages.VbDotNet); break; default: throw new ArgumentOutOfRangeException("language"); } }
public void CreateProperty(NetLanguage leng, StringBuilder sb) { switch (leng) { case NetLanguage.VbNet: sb.Append(IndentString); sb.AppendLine("Public Property " + this.Name + " As " + this.Type); sb.Append(IndentString); sb.AppendLine("Get"); sb.Append(IndentString); sb.Append(IndentString); sb.AppendLine("Return m" + this.Name); sb.Append(IndentString); sb.AppendLine("End Get"); sb.Append(IndentString); sb.AppendLine("Set(Value As " + this.Type + ")"); sb.Append(IndentString); sb.Append(IndentString); sb.AppendLine("m" + this.Name + " = Value"); sb.Append(IndentString); sb.AppendLine("End Set"); sb.Append(IndentString); sb.AppendLine("End Property"); break; case NetLanguage.CSharp: sb.Append(IndentString); sb.AppendLine("public " + this.Type + " " + this.Name); sb.Append(IndentString); sb.AppendLine("{"); sb.Append(IndentString); sb.Append(IndentString); sb.AppendLine("get { return m" + this.Name + ";}"); sb.Append(IndentString); sb.Append(IndentString); sb.AppendLine("set { m" + this.Name + " = value;}"); sb.Append(IndentString); sb.AppendLine("}"); break; default: break; } sb.AppendLine(); }
/// <summary> /// Get the sealed prefix, if needed /// </summary> /// <param name="lang">Language we are writing in</param> /// <returns>nothing, sealed or NotInheritable</returns> private string GetSealed(NetLanguage lang) { if (mSealedClass == false) { return(string.Empty); } switch (lang) { case NetLanguage.CSharp: return("sealed "); case NetLanguage.VbNet: return("NotInheritable "); } return(string.Empty); }
protected override void AddAttributes(NetLanguage leng, StringBuilder sb) { sb.Append(IndentString); switch (leng) { case NetLanguage.VbNet: sb.Append("<FieldFixedLength(" + this.FieldLength.ToString() + ")> "); break; case NetLanguage.CSharp: sb.AppendLine("[FieldFixedLength(" + this.FieldLength.ToString() + ")]"); break; default: break; } }
public static string GetVisibility(NetLanguage leng, NetVisibility visi) { switch (leng) { case NetLanguage.VbNet: switch (visi) { case NetVisibility.Private: return("Private"); case NetVisibility.Protected: return("Protected"); case NetVisibility.Public: return("Public"); case NetVisibility.Internal: return("Friend"); } break; case NetLanguage.CSharp: switch (visi) { case NetVisibility.Private: return("private"); case NetVisibility.Protected: return("protected"); case NetVisibility.Public: return("public"); case NetVisibility.Internal: return("internal"); } break; default: break; } return(""); }
private void ShowCode(string code, NetLanguage language) { mLastCode = code; var colorizer = new CodeColorizer(); switch (language) { case NetLanguage.CSharp: browserCode.DocumentText = GetDefaultCss() + colorizer.Colorize(code, Languages.CSharp); break; case NetLanguage.VbNet: browserCode.DocumentText = GetDefaultCss() + colorizer.Colorize(code, Languages.VbDotNet); break; default: throw new ArgumentOutOfRangeException("language"); } }
/// <summary> /// Create the converter in source code /// </summary> /// <param name="lang">C# or Visual Basic</param> /// <returns>Converter attribute in appropriate language</returns> internal string GetConverterCode(NetLanguage lang) { StringBuilder sb = new StringBuilder(); if (mKind != ConverterKind.None) { sb.Append("FieldConverter(ConverterKind." + mKind.ToString()); } else if (mTypeName != string.Empty) { if (lang == NetLanguage.CSharp) { sb.Append("FieldConverter(typeof(" + mTypeName + ")"); } else if (lang == NetLanguage.VbNet) { sb.Append("FieldConverter(GetType(" + mTypeName + ")"); } } else { return(string.Empty); } if (mArg1 != null && mArg1 != string.Empty) { sb.Append(", \"" + mArg1 + "\""); if (mArg2 != null && mArg2 != string.Empty) { sb.Append(", \"" + mArg2 + "\""); if (mArg3 != null && mArg3 != string.Empty) { sb.Append(", \"" + mArg3 + "\""); } } } sb.Append(")"); return(sb.ToString()); }
internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage leng) { if (mFieldQuoted) { if (leng == NetLanguage.CSharp) { var quoteStr = mQuoteChar.ToString(); if (mQuoteChar == '\'') quoteStr = @"\'"; attbs.AddAttribute("FieldQuoted('" + quoteStr + "', QuoteMode." + mQuoteMode.ToString() + ", MultilineMode." + mQuoteMultiline.ToString() + ")"); } else if (leng == NetLanguage.VbNet) { var quoteStr = mQuoteChar.ToString(); if (mQuoteChar == '"') quoteStr = "\"\""; attbs.AddAttribute("FieldQuoted(\"" + quoteStr + "\"c, QuoteMode." + mQuoteMode.ToString() + ", MultilineMode." + mQuoteMultiline.ToString() + ")"); } } }
/// <summary> /// Add the end of namespace to text /// </summary> /// <param name="lang">language we are generating</param> /// <param name="sb">class text to add to</param> private void EndNamespace(NetLanguage lang, StringBuilder sb) { if (mNamespace == "") { return; } sb.Append(StringHelper.NewLine); switch (lang) { case NetLanguage.CSharp: sb.Append("}"); break; case NetLanguage.VbNet: sb.Append("End Namespace"); break; } }
protected override void AddAttributes(NetLanguage leng, StringBuilder sb) { if (string.IsNullOrEmpty(QuotedChar) == false) { sb.Append(IndentString); switch (leng) { case NetLanguage.VbNet: sb.Append("<FieldQuoted(\"" + QuotedChar + "\")> "); break; case NetLanguage.CSharp: sb.AppendLine("[FieldQuoted(\"" + QuotedChar + "\")]"); break; default: break; } } }
private static void CreateDefaultNotificationTemplate(Site site) { if (!site.ExternalDevelopment) { var template = new PageTemplateDAL() { SiteId = site.Id, Name = "Default Notification Template", NetTemplateName = "Default_Notification_Template", TemplatePicture = "", Created = site.Created, Modified = site.Modified, LastModifiedBy = site.LastModifiedBy, Charset = "utf-8", Locale = 65001, Codepage = 1049, IsSystem = true, NetLanguageId = NetLanguage.GetcSharp().Id }; DefaultRepository.SimpleSave(template); } }
public AttributesBuilder(NetLanguage lang) { mLeng = lang; }
/// <summary> /// Create a class from a source file. /// </summary> /// <param name="filename">The filename with the source of the class.</param> /// <param name="lang">The language used to compile the class.</param> /// <returns>The compiled class.</returns> public static Type ClassFromSourceFile(string filename, NetLanguage lang) { return ClassFromSourceFile(filename, string.Empty, lang); }
/// <summary> /// Create a class from a source file. /// </summary> /// <param name="filename">The filename with the source of the class.</param> /// <param name="className">The name of the class to return.</param> /// <param name="lang">The language used to compile the class.</param> /// <returns>The compiled class.</returns> public static Type ClassFromSourceFile(string filename, string className, NetLanguage lang) { var reader = new StreamReader(filename); string classDef = reader.ReadToEnd(); reader.Close(); return ClassFromString(classDef, className, lang); }
/// <summary>Compiles the source code passed and returns the FIRST Type of the assembly.</summary> /// <param name="classStr">The Source Code of the class in the specified language</param> /// <returns>The Type generated by runtime compilation of the class source.</returns> /// <param name="lang">One of the .NET Languages</param> public static Type ClassFromString(string classStr, NetLanguage lang) { return ClassFromString(classStr, string.Empty, lang); }
/// <summary>Compiles the source code passed and returns the Type with the name className.</summary> /// <param name="classStr">The Source Code of the class in the specified language</param> /// <param name="className">The Name of the Type that must be returned</param> /// <returns>The Type generated by runtime compilation of the class source.</returns> /// <param name="lang">One of the .NET Languages</param> public static Type ClassFromString(string classStr, string className, NetLanguage lang) { if (classStr.Length < 4) throw new BadUsageException("There is not enough text to be a proper class, load your class and try again"); var cp = new CompilerParameters(); //cp.ReferencedAssemblies.Add("System.dll"); //cp.ReferencedAssemblies.Add("System.Data.dll"); //cp.ReferencedAssemblies.Add(typeof(ClassBuilder).Assembly.GetModules()[0].FullyQualifiedName); bool mustAddSystemData = false; lock (mReferencesLock) { if (mReferences == null) { ArrayList arr = new ArrayList(); foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { Module module = assembly.GetModules()[0]; if (module.Name == "mscorlib.dll" || module.Name == "<Unknown>") continue; if (module.Name == "System.Data.dll") mustAddSystemData = true; if (File.Exists(module.FullyQualifiedName)) arr.Add(module.FullyQualifiedName); } mReferences = (string[]) arr.ToArray(typeof (string)); } } cp.ReferencedAssemblies.AddRange(mReferences); cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.IncludeDebugInformation = false; var code = new StringBuilder(); switch (lang) { case NetLanguage.CSharp: code.Append("using System; using FileHelpers;"); if (mustAddSystemData) code.Append(" using System.Data;"); break; case NetLanguage.VbNet: if (CultureInfo.CurrentCulture.CompareInfo.IndexOf(classStr, "Imports System", CompareOptions.IgnoreCase) == -1) code.Append("Imports System\n"); if (CultureInfo.CurrentCulture.CompareInfo.IndexOf(classStr, "Imports FileHelpers", CompareOptions.IgnoreCase) == -1) code.Append("Imports FileHelpers\n"); if (mustAddSystemData && CultureInfo.CurrentCulture.CompareInfo.IndexOf(classStr, "Imports System.Data", CompareOptions.IgnoreCase) == -1) code.Append("Imports System.Data\n"); break; } code.Append(classStr); CompilerResults cr; CodeDomProvider prov = null; switch (lang) { case NetLanguage.CSharp: prov = CodeDomProvider.CreateProvider("cs"); break; case NetLanguage.VbNet: prov = CodeDomProvider.CreateProvider("vb"); break; } cr = prov.CompileAssemblyFromSource(cp, code.ToString()); if (cr.Errors.HasErrors) { var error = new StringBuilder(); error.Append("Error Compiling Expression: " + StringHelper.NewLine); foreach (CompilerError err in cr.Errors) { error.AppendFormat("Line {0}: {1}\n", err.Line, err.ErrorText); } throw new RunTimeCompilationException(error.ToString(), classStr, cr.Errors); } // Assembly.Load(cr.CompiledAssembly.); if (className != string.Empty) return cr.CompiledAssembly.GetType(className, true, true); else { Type[] ts = cr.CompiledAssembly.GetTypes(); if (ts.Length > 0) foreach (Type t in ts) { if (t.FullName.StartsWith("My.My") == false && t.IsDefined(typeof(TypedRecordAttribute), false)) return t; } throw new BadUsageException("The compiled assembly does not have any type inside."); } }
/// <summary> /// Returns the ENCRYPTED code for the current class in the specified language. /// </summary> /// <param name="lang">The language for the return code.</param> /// <returns>The ENCRYPTED code for the class that are currently building.</returns> public string GetClassBinaryCode(NetLanguage lang) { return Encrypt(GetClassSourceCode(lang), "withthefilehelpers1.0.0youcancodewithoutproblems1.5.0"); }
/// <summary> /// Change the selected language /// </summary> protected override void OnSelectedIndexChanged(EventArgs e) { base.OnSelectedIndexChanged(e); var value = (LanguageType)this.SelectedItem; if (Language != value.Language) { Language = value.Language; if (LanguageChange != null) LanguageChange(this, new EventLanguage(this.Language)); } }
/// <summary> /// Add any attributes to source (currently only the delimiter attribute) /// </summary> /// <param name="attbs">Attributes storage area to add to class</param> /// <param name="lang"></param> internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage lang) { if (mDelimiter == string.Empty) throw new BadUsageException("The Delimiter of the DelimiterClassBuilder can't be null or empty."); else attbs.AddAttribute("DelimitedRecord("+ GetDelimiter(mDelimiter, lang) +")"); }
/// <summary> /// Returns the source code for the current class in the specified language. /// </summary> /// <param name="lang">The language for the return code.</param> /// <returns>The Source Code for the class that are currently building.</returns> public string GetClassSourceCode(NetLanguage lang) { ValidateClass(); StringBuilder sb = new StringBuilder(100); BeginNamespace(lang, sb); AttributesBuilder attbs = new AttributesBuilder(lang); AddAttributesInternal(attbs); AddAttributesCode(attbs, lang); sb.Append(attbs.GetAttributesCode()); switch (lang) { case NetLanguage.VbNet: sb.Append(GetVisibility(lang, mVisibility) + GetSealed(lang) + "Class " + mClassName); sb.Append(StringHelper.NewLine); break; case NetLanguage.CSharp: sb.Append(GetVisibility(lang, mVisibility) + GetSealed(lang) + "class " + mClassName); sb.Append(StringHelper.NewLine); sb.Append("{"); break; } sb.Append(StringHelper.NewLine); sb.Append(StringHelper.NewLine); foreach (FieldBuilder field in mFields) { sb.Append(field.GetFieldCode(lang)); sb.Append(StringHelper.NewLine); } sb.Append(StringHelper.NewLine); switch (lang) { case NetLanguage.VbNet: sb.Append("End Class"); break; case NetLanguage.CSharp: sb.Append("}"); break; } EndNamespace(lang, sb); return sb.ToString(); }
internal override void AddAttributesCode(AttributesBuilder attbs, NetLanguage leng) { attbs.AddAttribute("FixedLengthRecord(FixedMode." + mFixedMode.ToString() + ")"); }
public ExampleFile(string filename, NetLanguage language) { Filename = filename; Language = language; }
internal string GetFieldCode(NetLanguage lang) { StringBuilder sb = new StringBuilder(100); AttributesBuilder attbs = new AttributesBuilder(lang); AddAttributesInternal(attbs, lang); AddAttributesCode(attbs, lang); sb.Append(attbs.GetAttributesCode()); NetVisibility visi = mVisibility; string currentName = mFieldName; if (mClassBuilder.GenerateProperties) { visi = NetVisibility.Private; currentName = "m" + mFieldName; } switch (lang) { case NetLanguage.VbNet: sb.Append(ClassBuilder.GetVisibility(lang, visi) + currentName + " As " + mFieldType); break; case NetLanguage.CSharp: sb.Append(ClassBuilder.GetVisibility(lang, visi) + mFieldType + " " + currentName+ ";"); break; default: break; } sb.Append(StringHelper.NewLine); if (mClassBuilder.GenerateProperties) { sb.Append(StringHelper.NewLine); switch (lang) { case NetLanguage.VbNet: sb.Append("Public Property " + mFieldName + " As " + mFieldType); sb.Append(StringHelper.NewLine); sb.Append(" Get"); sb.Append(StringHelper.NewLine); sb.Append(" Return m" + mFieldName); sb.Append(StringHelper.NewLine); sb.Append(" End Get"); sb.Append(StringHelper.NewLine); sb.Append(" Set (value As " + mFieldType + ")"); sb.Append(StringHelper.NewLine); sb.Append(" m" + mFieldName + " = value"); sb.Append(StringHelper.NewLine); sb.Append(" End Set"); sb.Append(StringHelper.NewLine); sb.Append("End Property"); break; case NetLanguage.CSharp: sb.Append("public " + mFieldType + " " + mFieldName); sb.Append(StringHelper.NewLine); sb.Append("{"); sb.Append(StringHelper.NewLine); sb.Append(" get { return m" + mFieldName + "; }"); sb.Append(StringHelper.NewLine); sb.Append(" set { m" + mFieldName + " = value; }"); sb.Append(StringHelper.NewLine); sb.Append("}"); break; default: break; } sb.Append(StringHelper.NewLine); sb.Append(StringHelper.NewLine); } return sb.ToString(); }
/// <summary> /// Create a language change event /// </summary> /// <param name="pLanguage"></param> internal EventLanguage( NetLanguage pLanguage ) { Language = pLanguage; }
private static string GetDelimiter(string delimiter, NetLanguage lang) { switch (lang) { case NetLanguage.CSharp: if (delimiter == "\t") return "\"\\t\""; else return "\"" + delimiter + "\""; case NetLanguage.VbNet: if (delimiter == "\t") return "VbTab"; else return "\"" + delimiter + "\""; default: throw new ArgumentOutOfRangeException("lang"); } }
/// <summary>Write the ENCRYPTED source code of the current class to a file. (In C#)</summary> /// <param name="filename">The file to write to.</param> /// <param name="lang">The .NET Language used to write the source code.</param> public void SaveToBinaryFile(string filename, NetLanguage lang) { StreamWriter writer = new StreamWriter(filename); writer.Write(GetClassBinaryCode(lang)); writer.Close(); }
void LanguageSelector_LanguageChange(object sender, LanguageSelector.EventLanguage e) { foreach (var item in this.Items) { this.Language = e.Language; LanguageType lang = item as LanguageType; if (lang.Language == e.Language) { this.SelectedItem = lang; return; } this.SelectedIndex = 0; } }
internal abstract void AddAttributesCode(AttributesBuilder attbs, NetLanguage leng);
/// <summary>Write the source code of the current class to a file. (In the specified language)</summary> /// <param name="filename">The file to write to.</param> /// <param name="lang">The .NET Language used to write the source code.</param> public void SaveToSourceFile(string filename, NetLanguage lang) { var writer = new StreamWriter(filename); writer.Write(GetClassSourceCode(lang)); writer.Close(); }
private void AddAttributesInternal(AttributesBuilder attbs, NetLanguage leng) { if (mFieldOptional == true) attbs.AddAttribute("FieldOptional()"); if (mFieldIgnored == true) attbs.AddAttribute("FieldIgnored()"); if (mFieldInNewLine == true) attbs.AddAttribute("FieldInNewLine()"); if (mFieldNullValue != null) { if (mFieldNullValue is string) attbs.AddAttribute("FieldNullValue(\"" + mFieldNullValue.ToString() + "\")"); else { string t = ClassBuilder.TypeToString(mFieldNullValue.GetType()); string gt = string.Empty; if (leng == NetLanguage.CSharp) gt = "typeof(" + t + ")"; else if (leng == NetLanguage.VbNet) gt = "GetType(" + t + ")"; attbs.AddAttribute("FieldNullValue("+ gt +", \""+ mFieldNullValue.ToString() +"\")"); } } attbs.AddAttribute(mConverter.GetConverterCode(leng)); if (mTrimMode != TrimMode.None) { if (" \t" == mTrimChars) attbs.AddAttribute("FieldTrim(TrimMode."+ mTrimMode.ToString()+")"); else attbs.AddAttribute("FieldTrim(TrimMode." + mTrimMode.ToString() + ", \"" + mTrimChars.ToString() + "\")"); } }
/// <summary> /// Add the end of namespace to text /// </summary> /// <param name="lang">language we are generating</param> /// <param name="sb">class text to add to</param> private void EndNamespace(NetLanguage lang, StringBuilder sb) { if (mNamespace == string.Empty) return; sb.Append(StringHelper.NewLine); switch (lang) { case NetLanguage.CSharp: sb.Append("}"); break; case NetLanguage.VbNet: sb.Append("End Namespace"); break; } }