private static void OnAssemblyLoad(object sender, AssemblyLoadEventArgs e)
{
if (e.LoadedAssembly.GetCustomAttributes <AssemblyMetadataAttribute>().Any(m => m.Key == "gui"))// || m.Key == "module"
{
var types = (Type[])null;
try { types = e.LoadedAssembly?.GetExportedTypes(); }
catch (Exception ex)
{
Helper.OnException(ex);
return;
}
foreach (var item in types)
{
if (TypeHelper.IsInterface(item, typeof(IModuleInitialize)))
{
try
{
var imodule = (IModuleInitialize)EmitInvoker.CreateObject(item);
imodule.Initialize();
}
catch (Exception ex)
{
Helper.OnException(ex);
}
}
}
}
}
public ReferencingGenerator(TableGenerator table, PropertyInfo property, ReferencingAttribute referencingAttribuite)
{
if (!property.PropertyType.IsGenericType)
{
throw new InvalidOperationException($"{nameof(ReferencingAttribute)} Property type expect generic enumerable!");
}
var referenceTable = DBTable.GetTableAttributeInherit(property.PropertyType.GetGenericArguments()[0]);
if (referenceTable == null)
{
throw new InvalidOperationException($"{nameof(ReferencingAttribute)} Property type expect {nameof(TableAttribute)}!");
}
var referenceColumn = referenceTable.GetColumnByProperty(referencingAttribuite.ReferenceProperty);
if (referenceColumn == null)
{
throw new InvalidOperationException($"{nameof(ReferencingAttribute.ReferenceProperty)} expect {nameof(ColumnAttribute)}!");
}
Attribute = referencingAttribuite;
Table = table;
PropertyInfo = property;
ReferenceTable = referenceTable;
ReferenceColumn = referenceColumn;
PropertyInvoker = EmitInvoker.Initialize(property, true);
}
public List <DockPage> GetPages(Type documentType)
{
var documentWidgets = new List <DockPage>();
foreach (var type in GetTypes(documentType))
{
var name = type.Name;
var page = dock.GetPage(name);
if (page == null)
{
if (!TypeBinding.TryGetValue(type, out var widgetType))
{
widgetType = typeof(DocumentDetailView <>);
}
if (widgetType.IsGenericType)
{
widgetType = widgetType.MakeGenericType(type, type);
}
var widget = (Widget)EmitInvoker.CreateObject(widgetType);
widget.Name = name;
page = dock.Put(widget, TypeHelper.IsBaseType(type, typeof(DocumentData)) ? DockType.LeftBottom : DockType.Content);
}
documentWidgets.Add(page);
}
return(documentWidgets);
}
public virtual DBForeignKey Generate()
{
if (ReferenceType == null ||
Table == null || Table.Schema == null ||
Column == null || Column.Column == null)
{
throw new Exception($"{nameof(ReferenceAttribute)} is not initialized!");
}
if (ForeignKey == null)
{
var referenceTable = CheckReference();
ForeignKey = new DBForeignKey()
{
Table = Table.Table,
Column = Column.Column,
Reference = referenceTable.PrimaryKey,
Name = Attribute.Name,
};
Table.Table.Foreigns.Add(ForeignKey);
}
Column.Column.IsReference = true;
ForeignKey.Property = PropertyInfo.Name;
ForeignKey.PropertyInfo = PropertyInfo;
if (ForeignKey.PropertyInvoker == null)
{
ForeignKey.PropertyInvoker = EmitInvoker.Initialize(PropertyInfo, true);
}
return(ForeignKey);
}
public T GetCached <T>(string name)
{
if (!Cache.TryGetValue(name, out object o))
{
Cache[name] = o = EmitInvoker.CreateObject(typeof(T), true);
}
return((T)o);
}
protected virtual IEnumerable ListFind(string filter)
{
if (listSource is ISelectable selectable)
{
return(selectable.Select(ListProperty, CompareType.Like, filter));
}
return(ListHelper.Search(listSource, EmitInvoker.Initialize(listSource[0].GetType(), ListProperty), filter, CompareType.Like, null));
}
public void TestQuery()
{
var query = new Query <TestClass>(new[] {
new QueryParameter <TestClass>()
{
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Name)),
Comparer = CompareType.Like,
Value = "Threading"
},
new QueryParameter <TestClass>()
{
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Field)),
Comparer = CompareType.NotEqual,
Value = 6
}
});
var result = list.Select(query);
Assert.AreEqual(1, result.Count(), "Select by Query Name and Field Fail");
query = new Query <TestClass>(new[] {
new QueryParameter <TestClass>()
{
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Name)),
Comparer = CompareType.Like,
Value = "Threading"
},
new QueryParameter <TestClass>()
{
Logic = LogicType.AndNot,
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Field)),
Comparer = CompareType.Equal,
Value = 6
}
});
result = list.Select(query);
Assert.AreEqual(1, result.Count(), "Select by Query Name and not Field Fail");
query = new Query <TestClass>(new[] {
new QueryParameter <TestClass>()
{
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Name)),
Comparer = CompareType.Like,
Value = "Threading"
},
new QueryParameter <TestClass>()
{
Logic = LogicType.Or,
Invoker = EmitInvoker.Initialize <TestClass>(nameof(TestClass.Field)),
Comparer = CompareType.Less,
Value = 3
}
});
result = list.Select(query);
Assert.AreEqual(4, result.Count(), "Select by Query Name or Field Fail");
}
public T GetGlobalCached <T>()
{
var name = typeof(T).Name;
if (!GlobalCache.TryGetValue(name, out object o))
{
GlobalCache[name] = o = EmitInvoker.CreateObject(typeof(T), true);
}
return((T)o);
}
public void InitProcedure(DBItem owner, StageProcedure param)
{
if (!(param.Procedure is DBProcedure proc) || param.ProcedureType != StageParamProcudureType.Manual)
{
return;
}
string name = "procedure" + proc.Name;
if (proc.ProcedureType == ProcedureTypes.Query)
{
DockPage page = dock.GetPage(name);
if (page == null)
{
page = dock.Put(new PQueryView
{
Name = name,
Text = param.Name == null || param.Name.Length == 0 ? proc.ToString() : param.Name,
Document = document,
Procedure = proc
}, DockType.Content);
}
page.Tag = owner;
}
Type t = proc.ProcedureType == ProcedureTypes.Assembly || proc.ProcedureType == ProcedureTypes.Source ? proc.GetObjectType() : null;
if (t != null && !TypeHelper.IsBaseType(t, typeof(Window)) && TypeHelper.IsBaseType(t, typeof(Widget)))
{
DockPage page = dock.GetPage(name);
if (page == null)
{
var control = (Widget)EmitInvoker.CreateObject(t, true);
control.Name = name;
if (control is IText)
{
((IText)control).Text = param.Name == null || param.Name.Length == 0 ? proc.ToString() : param.Name;
}
page = dock.Put(control, DockType.Content);
}
page.Tag = owner;
}
else
{
if (!(toolProcedures.DropDown?.Items[name] is MenuItemProcedure item))
{
item = new MenuItemProcedure(proc)
{
Name = name
};
item.Click += ProcedureItemClick;
toolProcedures.DropDown.Items.Add(item);
}
item.Tag = owner;
}
}
public virtual DBTable CreateTable()
{
Debug.WriteLine($"Generate {Attribute.TableName} - {this.ItemType.Name}");
var type = typeof(DBTable <>).MakeGenericType(ItemType);
// var logicType = ItemType.Assembly.ExportedTypes.FirstOrDefault(p => p.BaseType == type);
var table = (DBTable)EmitInvoker.CreateObject(type);
table.Name = Attribute.TableName;
table.Schema = Schema;
return(table);
}
public virtual DBTable CreateTable()
{
if (TableAttribute == null)
{
throw new InvalidOperationException("Table attribute not initializes!");
}
Debug.WriteLine($"Generate {TableAttribute.Attribute.TableName} - {Type.Name}");
var table = (DBTable)EmitInvoker.CreateObject(typeof(DBVirtualTable <>).MakeGenericType(Type));
table.Name = Type.Name;
table.Schema = Schema;
((IDBVirtualTable)table).BaseTable = TableAttribute.Table;
table.DisplayName = Type.Name;
return(table);
}
protected void MenuViewItemClick(object sender, EventArgs e)
{
var item = (ToolWidgetHandler)sender;
if (item.Widget == null)
{
item.Widget = dock.Find(item.Name);
if (item.Widget == null)
{
item.Widget = (Widget)EmitInvoker.CreateObject(item.WidgetType);
item.Widget.Name = item.Name;
if (item.Widget is ILocalizable)
{
((ILocalizable)item.Widget).Localize();
}
}
}
ShowControl(item.Widget);
}
public static void Start(string[] args, ToolkitType type, Type splashType, Type mainType)
{
Application.Initialize(type);
GuiService.UIThread = Thread.CurrentThread;
//exceptions
Application.UnhandledException += (sender, e) =>
{
Helper.OnException(e.ErrorException);
};
//Load Configuration
for (int i = 0; i < args.Length; i++)
{
string s = args[i];
if (s.Equals("-config"))
{
var obj = Serialization.Deserialize(args[++i]);
using (var op = new ListExplorer())
{
op.DataSource = obj;
op.ShowWindow((WindowFrame)null);
}
Application.Run();
Serialization.Serialize(obj, args[i]);
return;
}
}
using (var splash = (Splash)EmitInvoker.CreateObject(splashType))
{
splash.Run();
}
using (var main = (MainWindow)EmitInvoker.CreateObject(mainType))
{
main.LoadConfiguration();
main.Show();
Application.Run();
}
Application.Dispose();
}
private void ToolLoadFileClick(object sender, EventArgs e)
{
var dialog = new OpenFileDialog()
{
Multiselect = true
};
if (dialog.Run(ParentWindow))
{
foreach (string fileName in dialog.FileNames)
{
string name = Path.GetFileName(fileName);
var query = new Query <DBProcedure>(new[]
{
new QueryParameter <DBProcedure>()
{
Invoker = EmitInvoker.Initialize <DBProcedure>(nameof(DBProcedure.DataName)),
Value = name
},
new QueryParameter <DBProcedure>()
{
Invoker = EmitInvoker.Initialize <DBProcedure>(nameof(DBProcedure.ProcedureType)),
Value = ProcedureTypes.File
},
});
if (!(CurrentSchema.Procedures.Find(query) is DBProcedure procedire))
{
procedire = new DBProcedure
{
ProcedureType = ProcedureTypes.File,
DataName = name,
Name = Path.GetFileNameWithoutExtension(name)
};
}
procedire.Data = File.ReadAllBytes(fileName);
procedire.Stamp = File.GetLastWriteTime(fileName);
procedire.Save();
}
MessageDialog.ShowMessage(ParentWindow, Locale.Get("FlowExplorer", "Files load complete!"), "File Loader!");
}
}
public static PullIndex Create(Pull pull, Type type, Type keyType, IComparer valueComparer)
{
object nullKey = ListIndexFabric.GetNullKey(keyType);
object keyComparer = null;
if (keyType == typeof(string))
{
keyComparer = StringComparer.OrdinalIgnoreCase;
}
if (keyType.IsValueType || keyType.IsEnum)
{
var gtype = typeof(NullablePullIndex <,>).MakeGenericType(type, keyType);
return((PullIndex)EmitInvoker.CreateObject(gtype, ctorTypes, new object[] { pull, nullKey, valueComparer, keyComparer }, true));
}
else
{
var gtype = typeof(PullIndex <,>).MakeGenericType(type, keyType);
return((PullIndex)EmitInvoker.CreateObject(gtype, ctorTypes, new object[] { pull, nullKey, valueComparer, keyComparer }, true));
}
}
public static Assembly Compile(string outFile, IEnumerable <DBProcedure> procedures, out CompilerResults result, bool inMemory)
{
if (outFile == null)
{
outFile = "temp";
}
EmitInvoker.DeleteCache();
//
string path = Path.Combine(Helper.GetDirectory(Environment.SpecialFolder.LocalApplicationData, true), "Temp", outFile);
if (Directory.Exists(path))
{
Directory.Delete(path);
}
Directory.CreateDirectory(path);
List <string> sources = new List <string>();
foreach (var procedure in procedures)
{
if (procedure.ProcedureType == ProcedureTypes.Source && procedure.Source != null && procedure.Source.Length > 0)
{
string file = Path.Combine(path, procedure.Name + ".cs");
File.WriteAllText(file, procedure.Source);
sources.Add(file);
}
}
Assembly assembly = Compile(outFile, sources.ToArray(), out result, inMemory);
foreach (var procedure in procedures)
{
if (procedure.ProcedureType == ProcedureTypes.Source && procedure.Source != null && procedure.Source.Length > 0)
{
procedure.TempAssembly = assembly;
}
}
//Directory.Delete(path, true);
return(assembly);
}
public object CreateObject(ExecuteArgs arg = null)
{
object temp = null;
if (ProcedureType == ProcedureTypes.Assembly || ProcedureType == ProcedureTypes.Source)
{
temp = EmitInvoker.CreateObject(GetObjectType(), true);
}
else if (ProcedureType == ProcedureTypes.Table)
{
temp = DBService.Schems.ParseTable(Source);
}
else if (ProcedureType == ProcedureTypes.Constant)
{
temp = Source;
}
else
{
temp = BuildCommand(arg.Parameters);
}
return(temp);
}
protected virtual void OnNodeCheck(ListExplorerNode node)
{
if (node.DataSource == null)
{
return;
}
foreach (var property in node.DataSource.GetType().GetProperties())
{
if (TypeHelper.GetBrowsable(property) && TypeHelper.IsList(property.PropertyType) && !TypeHelper.IsIndex(property))
{
Node propertyNode = InitNode(property, EmitInvoker.GetValue(property, node.DataSource));
if (propertyNode != null)
{
propertyNode.Group = node;
}
else
{
Tree.Nodes.Add(propertyNode);
}
}
}
node.Check = true;
}
public ParameterInvoker(ParameterAttribute parameter, MemberInfo member)
{
Parameter = parameter;
Member = member;
MemberInvoker = EmitInvoker.Initialize(member, true);
}
public void BindData(DBItem dataSource, DBColumn column, DBTable refer = null)
{
if (Column != column && dataSource?.GetType() != DataSource.GetType())
{
Binding?.Dispose();
if (column != null)
{
CellEditor = TableLayoutList.InitCellEditor(column);
if (CellEditor is CellEditorTable && refer != null)
{
((CellEditorTable)CellEditor).Table = refer;
}
Binding = new InvokeBinder <DBItem, FieldEditor>(dataSource, column, this, EmitInvoker.Initialize <FieldEditor>(nameof(Value)));
}
}
DataSource = dataSource;
}
public ListEditor(LayoutList list)
: base()
{
handleGetEditor = ListOnGetCellEditor;
toolStatusArchive = new ToolMenuItem()
{
Name = "Archive", Tag = DBStatus.Archive, Glyph = GlyphType.FlagCheckered
};
toolStatusEdit = new ToolMenuItem()
{
Name = "Edit", Tag = DBStatus.Edit, GlyphColor = Colors.DarkOrange, Glyph = GlyphType.Flag
};
toolStatusError = new ToolMenuItem()
{
Name = "Error", Tag = DBStatus.Error, GlyphColor = Colors.DarkRed, Glyph = GlyphType.Flag
};
toolStatusDelete = new ToolMenuItem()
{
Name = "Delete", Tag = DBStatus.Delete, GlyphColor = Colors.Purple, Sensitive = false, Glyph = GlyphType.Flag
};
toolStatusActual = new ToolMenuItem()
{
Name = "Actual", Tag = DBStatus.Actual, GlyphColor = Colors.DarkGreen, Sensitive = false, Glyph = GlyphType.Flag
};
toolStatusNew = new ToolMenuItem()
{
Name = "New", Tag = DBStatus.New, GlyphColor = Colors.DarkBlue, Sensitive = false, Glyph = GlyphType.Flag
};
toolStatus = new ToolSplit()
{
Name = "Status", Glyph = GlyphType.Flag, DropDown = new Menubar {
Name = "Status"
}
};
toolStatus.DropDownItems.AddRange(new[] {
toolStatusNew,
toolStatusActual,
toolStatusEdit,
toolStatusArchive,
toolStatusError,
toolStatusDelete
});
toolStatus.ButtonClick += OnToolStatusClick;
toolStatus.ItemClick += ToolStatusItemClicked;
toolPosition = new ToolLabel {
Name = "Position", Text = "_ / _"
};
toolCopy = new ToolMenuItem(OnToolCopyClick)
{
Name = "Copy", Glyph = GlyphType.CopyAlias
};
toolInsert = new ToolMenuItem(OnToolInsertClick)
{
Name = "Insert", Glyph = GlyphType.Plus
};
toolCut = new ToolItem(OnToolCutClick)
{
Name = "Cut", DisplayStyle = ToolItemDisplayStyle.Text, Visible = false, Glyph = GlyphType.CutAlias
};
toolLog = new ToolItem(OnToolLogClick)
{
Name = "Logs", DisplayStyle = ToolItemDisplayStyle.Text, Glyph = GlyphType.History
};
toolAccess = new ToolItem(ToolAccessClick)
{
Name = "Access", DisplayStyle = ToolItemDisplayStyle.Text, CheckOnClick = true, Glyph = Glyph = GlyphType.Key
};
toolRefresh = new ToolItem(OnToolRefreshClick)
{
Name = "Refresh", DisplayStyle = ToolItemDisplayStyle.Text, Glyph = GlyphType.Refresh
};
toolSave = new ToolItem(OnToolSaveClick)
{
Name = "Save", DisplayStyle = ToolItemDisplayStyle.Text, GlyphColor = Colors.Blue, Glyph = GlyphType.SaveAlias
};
toolLoad = new ToolItem(OnToolLoadClick)
{
Name = "Load", DisplayStyle = ToolItemDisplayStyle.Text, Glyph = GlyphType.FolderOpen
};
toolAdd = new ToolDropDown(toolInsert, toolCopy)
{
Name = "Add", DisplayStyle = ToolItemDisplayStyle.Text, GlyphColor = Colors.Green, Glyph = GlyphType.PlusCircle
};
toolRemove = new ToolItem(OnToolRemoveClick)
{
Name = "Remove", DisplayStyle = ToolItemDisplayStyle.Text, GlyphColor = Colors.Red, Glyph = GlyphType.MinusCircle
};
toolEdit = new ToolItem(OnToolEditClick)
{
Name = "Edit", DisplayStyle = ToolItemDisplayStyle.Text, Visible = false, GlyphColor = Colors.SandyBrown, Glyph = GlyphType.Pencil
};
bar = new Toolsbar(
toolRefresh,
toolLoad,
toolSave,
new ToolSeparator(),
toolAccess,
toolAdd,
toolRemove,
//toolEdit,
toolCut,
toolLog,
toolStatus,
new ToolSeparator()
{
FillWidth = true
},
toolPosition)
{
Name = "ListEditor"
};
box = new VBox()
{
Spacing = 1
};
box.PackStart(bar, false, false);
container = new VPaned()
{
Name = "container"
};
container.Panel1.Content = box;
PackStart(container, true, true);
List = list;
fields = (LayoutList)EmitInvoker.CreateObject(list.GetType());
fields.EditMode = EditModes.ByClick;
fields.RetriveCellEditor += handleGetEditor;
toolWindow = new ToolWindow()
{
Target = fields, Mode = ToolShowMode.Dialog
};
toolWindow.ButtonAcceptClick += OnToolWindowAcceptClick;
toolWindow.ButtonCloseClick += OnToolWindowCancelClick;
Localize();
}
public static SelectableList <TestResult> Test(int c = 100000)
{
var list = new SelectableList <TestResult>();
var test = new TestClass();
var aTest = test as TestAbstract;
var iTest = test as IOrder;
var pOrder = test.GetType().GetProperty("Order");
var pItem = test.GetType().GetProperty("Item", new Type[] { typeof(string) });
var cDefault = typeof(TestClass).GetConstructor(Type.EmptyTypes);
var cParam = typeof(TestClass).GetConstructor(new Type[] { typeof(int), typeof(string) });
var aOrder = EmitInvoker.Initialize(pOrder);
var aItem = EmitInvoker.Initialize(pItem, "fdsfds");
var aDefault = EmitInvoker.Initialize(cDefault);
var aParam = EmitInvoker.Initialize(cParam);
var param = new object[] { "cfsdf" };
var paramDefault = new object[] { };
var paramParam = new object[] { 12, "1dasdas" };
var actionBinder = new ActionInvoker <TestClass, int>(
nameof(TestClass.Order),
(item) => item.Order,
(item, value) => item.Order = value);
int val;
string sval;
object oval;
Stopwatch watch = new Stopwatch();
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = actionBinder.GetValue(test);
//tc.Order = val;
}
watch.Stop();
list.Add(new TestResult("Property Get", "Action", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = test.Order;
//tc.Order = val;
}
watch.Stop();
list.Add(new TestResult("Property Get", "Direct", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = aTest.Order;
//tc.Order = val;
}
watch.Stop();
list.Add(new TestResult("Property Get", "Abstract", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = iTest.Order;
//tc.Order = val;
}
watch.Stop();
list.Add(new TestResult("Property Get", "Interface", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = pOrder.GetValue(test, null);
}
watch.Stop();
list.Add(new TestResult("Property Get", "Reflection", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = (int)pOrder.GetValue(test, null);
}
watch.Stop();
list.Add(new TestResult("Property Get", "Reflection UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = aOrder.GetValue(test);
}
watch.Stop();
list.Add(new TestResult("Property Get", "Emit Invoke", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
val = (int)aOrder.GetValue(test);
}
watch.Stop();
list.Add(new TestResult("Property Get", "Emit Invoke UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
sval = test["fsdfdsf"];
}
watch.Stop();
list.Add(new TestResult("Property Index", "Direct", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = pItem.GetValue(test, param);
}
watch.Stop();
list.Add(new TestResult("Property Index", "Reflection", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
sval = (string)pItem.GetValue(test, param);
}
watch.Stop();
list.Add(new TestResult("Property Index", "Reflection UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = aItem.GetValue(test);
}
watch.Stop();
list.Add(new TestResult("Property Index", "Emit Invoke", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
sval = (string)aItem.GetValue(test);
}
watch.Stop();
list.Add(new TestResult("Property Index", "Emit Invoke UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
test = new TestClass();
}
watch.Stop();
list.Add(new TestResult("Constructor", "Direct", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
test = (TestClass)cDefault.Invoke(paramDefault);
}
watch.Stop();
list.Add(new TestResult("Constructor", "Reflection UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
//object[] obj = new object[] { };
for (int i = 0; i <= c; i++)
{
test = (TestClass)aDefault.Create(paramDefault);
}
watch.Stop();
list.Add(new TestResult("Constructor", "Emit Invoke UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
test = new TestClass(12, "dsadas");
}
watch.Stop();
list.Add(new TestResult("Constructor Params", "Direct", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = cParam.Invoke(paramParam);
}
watch.Stop();
list.Add(new TestResult("Constructor Params", "Reflection", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
test = (TestClass)cParam.Invoke(paramParam);
}
watch.Stop();
list.Add(new TestResult("Constructor Params", "Reflection UNBOX", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
oval = aParam.Create(paramParam);
}
watch.Stop();
list.Add(new TestResult("Constructor Params", "Emit Invoke", watch.Elapsed));
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
test = (TestClass)aParam.Create(paramParam);
}
watch.Stop();
list.Add(new TestResult("Constructor Params", "Emit Invoke UNBOX", watch.Elapsed));
TestClass p1 = new TestClass(123112365, "test string compa3rision");
TestClass p2 = new TestClass(124312312, "test string comp4arision");
//Compare string
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
p1.Comment.CompareTo(p2.Comment);
}
watch.Stop();
list.Add(new TestResult("Compare String", "Direct", watch.Elapsed));
//Compare string Invariant
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
CultureInfo.InvariantCulture.CompareInfo.Compare(p1.Comment, p2.Comment, CompareOptions.Ordinal);
}
watch.Stop();
list.Add(new TestResult("Compare String", "Direct Invariant", watch.Elapsed));
//Compare Accessor string
watch.Reset();
watch.Start();
var ce = new InvokerComparer(EmitInvoker.Initialize(typeof(TestClass).GetProperty("Comment")), ListSortDirection.Ascending);
for (int i = 0; i <= c; i++)
{
ce.Compare(p1, p2);
}
watch.Stop();
list.Add(new TestResult("Compare String", "Emit Invoke Property", watch.Elapsed));
//Compare integer
watch.Reset();
watch.Start();
for (int i = 0; i <= c; i++)
{
p1.Order.CompareTo(p2.Order);
}
watch.Stop();
list.Add(new TestResult("Compare Int", "Direct", watch.Elapsed));
//Compare Accessor Int
watch.Reset();
watch.Start();
ce = new InvokerComparer(EmitInvoker.Initialize(typeof(TestClass).GetProperty("Order")), ListSortDirection.Ascending);
for (int i = 0; i <= c; i++)
{
ce.Compare(p1, p2);
}
watch.Stop();
list.Add(new TestResult("Compare Int", "Emit Invoke Property", watch.Elapsed));
return(list);
}
public void Bind(object bindSource, string bindProperty)
{
Bind(bindSource, bindSource == null ? null : EmitInvoker.Initialize(bindSource.GetType(), bindProperty));
}
protected virtual IInvoker GetFileNameInvoker(object dataSource)
{
return(EmitInvoker.Initialize(dataSource.GetType(), propertyFileName));
}
public CodeAttributeCache(CodeAttribute attribute, MemberInfo member)
{
Attribute = attribute;
Member = member;
MemberInvoker = EmitInvoker.Initialize(member, true);
}
