/// <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;
}
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;
}
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;
}
}
