public void MultiThreadCacheClear()
{
var o = TypeAccessor.CreateInstanceEx <MultiThread>();
o.Clear();
Action <object> action = (j) =>
{
Console.WriteLine("Thread {1} Begin increment {0}", j, Thread.CurrentThread.ManagedThreadId);
o.GetValue();
Thread.Sleep(50);
Console.WriteLine("Thread {1} End increment {0}", j, Thread.CurrentThread.ManagedThreadId);
};
Action <Object> clear = (k) =>
{
Console.WriteLine("Thread {1} Begin clear {0}", k, Thread.CurrentThread.ManagedThreadId);
o.Clear();
Thread.Sleep(50);
Console.WriteLine("Thread {1} End clear {0}", k, Thread.CurrentThread.ManagedThreadId);
};
var tasks = new List <Task>(20);
for (int i = 0; i < 20; i++)
{
tasks.Add(i % 2 == 0 ? Task.Factory.StartNew(action, i) : Task.Factory.StartNew(clear, i));
}
var ok = Task.WaitAll(tasks.ToArray(), 25 * 50);
Task.WaitAll(tasks.ToArray());
Assert.True(ok);
}
public object AddNew()
{
if (AllowNew == false)
{
throw new NotSupportedException();
}
EndNew();
object o = TypeAccessor.CreateInstanceEx(_itemType);
_newObject = o as INotifyObjectEdit;
if (_newObject != null)
{
_newObject.ObjectEdit += NewObject_ObjectEdit;
}
_newItemIndex = _list.Add(o);
OnAddItem(o, _newItemIndex);
Debug.WriteLine(string.Format("AddNew - ({0})", o.GetType().Name));
return(o);
}
public void MultiThreadTest()
{
var o = TypeAccessor.CreateInstanceEx <MultiThread>();
o.Clear();
Action <object> increment = (j) =>
{
Console.WriteLine("Start increment {0}", j);
o.GetValue();
Thread.Sleep(100);
Console.WriteLine("End increment {0}", j);
};
var tasks = new List <Task>(10);
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Factory.StartNew(increment, i));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(1, MultiThread.Value);
}
public void MultiThreadThrow()
{
MultiThread.Value = 0;
var o = TypeAccessor.CreateInstanceEx <MultiThread>();
Action <object> action = (n) =>
{
try
{
Console.WriteLine("Thread {1} Begin Throw {0}", n, Thread.CurrentThread.ManagedThreadId);
o.Throw();
}
catch
{
Thread.Sleep(50);
Console.WriteLine("Thread {1} End Throw {0}", n, Thread.CurrentThread.ManagedThreadId);
}
};
var tasks = new List <Task>(10);
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Factory.StartNew(action, i));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(10, MultiThread.Value);
}
private static void SetConverter(
ExpressionBuilder builder,
MemberInfo member,
ISqlExpression expr)
{
var sqlValue = expr as SqlValueBase;
if (sqlValue == null)
{
return;
}
var mm = builder.MappingSchema.GetObjectMapper(member.DeclaringType)
.First(_ => _.MemberName == member.Name);
if (TypeHelper.IsEnumOrNullableEnum(mm.Type))
{
var memberAccessor = TypeAccessor.GetAccessor(member.DeclaringType)[member.Name];
sqlValue.SetEnumConverter(memberAccessor, builder.MappingSchema);
}
else if (!mm.SupportsValue)
{
sqlValue.ValueConverter = _ =>
{
var obj = TypeAccessor.CreateInstanceEx(member.DeclaringType);
mm.MemberAccessor.SetValue(obj, _);
return(mm.GetValue(obj));
};
}
}
public void AnyNameTest()
{
var o = TypeAccessor.CreateInstanceEx <TestObject>();
var ar = o.AnyName(2, null, null, null);
Assert.AreEqual(2, o.AnyName(ar));
}
public void GenericTest()
{
var o = TypeAccessor.CreateInstanceEx <TestObject <DateTime> >();
var now = DateTime.Now;
var ar = o.BeginTest(now);
Assert.AreEqual(now, o.EndTest(ar));
}
public static A CreateInstance(DbManager dbManager, bool dispose)
{
A da = TypeAccessor<A>.CreateInstanceEx();
da.SetDbManager(dbManager, dispose);
return da;
}
protected TypeDescriptorExtender(Type baseType)
{
if (baseType == null)
{
throw new ArgumentNullException("baseType");
}
_baseObject = TypeAccessor.CreateInstanceEx(baseType);
}
public static T CreateInstance <T>(DbManager dbManager, bool dispose)
where T : DataAccessor
{
T da = TypeAccessor <T> .CreateInstanceEx();
da.SetDbManager(dbManager, dispose);
return(da);
}
public virtual BizEntity Clone()
{
BizEntity obj = (BizEntity)TypeAccessor.CreateInstanceEx(GetType());
CopyTo(obj);
obj.AcceptChanges();
return(obj);
}
public void NoCallbackTest()
{
var o = TypeAccessor.CreateInstanceEx <TestObject>();
Assert.AreEqual(1, o.Test(1, null));
var ar = o.BeginTest(2, "1234");
Assert.AreEqual(2, o.EndTest(ar));
}
public void CustomGenerateTest()
{
var o = TypeAccessor.CreateInstanceEx <CustomObject>();
var type = o.GetType();
var attr = (NonInheritedAttribute)Attribute.GetCustomAttribute(type, typeof(NonInheritedAttribute));
Assert.That(attr, Is.Not.Null);
Assert.That(attr.Type, Is.EqualTo(typeof(int)));
Assert.That(attr.NamedArgument, Is.EqualTo("NamedValue"));
}
public void NoStateTest()
{
var o = TypeAccessor <TestObject> .CreateInstanceEx();
Assert.AreEqual(1, o.Test(1, null));
var ar = o.BeginTest(2, null, null);
Assert.AreEqual(2, o.EndTest(ar));
}
public IndividualViewModel()
{
Card = TypeAccessor <PersonCardNatural> .CreateInstanceEx();
Card.Person = TypeAccessor <Person> .CreateInstanceEx();
IncorporationForms = Repository.IncorporationForms.GetAllByPersonKind(2);
Card.Person.TerritoryID = null;
HelpTopic = "CreateIndividual";
}
public PersonModel()
{
Card = TypeAccessor <PersonCard> .CreateInstanceEx();
Card.TerritoryID = Card.Requisites.TerritoryID = null;
ResponsibleEmployees = new List <Naturals.PersonModel.SimplePersonModelClass>();
CurrentEmployeeID = UserContext.Current.EmployeeInfo.ID;
PersonThemesAndCatalogs = new List <dynamic>();
this.PersonTypes = new PersonTypesList {
};
}
public PersonModel()
{
EditCard = false;
Card = TypeAccessor <PersonCard> .CreateInstanceEx();
//Card.TerritoryID = Territories.ObjectModel.Territory.Russia;
ResponsibleEmployees = new List <SimplePersonModelClass>();
CurrentEmployeeID = UserContext.Current.EmployeeInfo.ID;
PersonThemesAndCatalogs = new List <dynamic>();
this.PersonTypes = new PersonTypesList {
};
}
/// <summary>
/// Implements the requested interface for supplied object.
/// If the supplied object implements the interface, the object itself will be returned.
/// Otherwise a convenient duck object will be created.
/// </summary>
/// <param name="interfaceType">An interface type to implement.</param>
/// <param name="baseObjectType">Any type which has all members of the given interface.
/// When this parameter is set to null, the object type will be used.</param>
/// <param name="obj">An object which type expected to have all members of the given interface.</param>
/// <returns>An object which implements the interface.</returns>
public static object Implement(Type interfaceType, Type baseObjectType, object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var objType = obj.GetType();
if (TypeHelper.IsSameOrParent(interfaceType, objType))
{
return(obj);
}
if (obj is DuckType)
{
var duckObject = (DuckType)obj;
if (duckObject.Objects.Length == 1)
{
// Switch to underlying objects when a duck object was passed.
//
return(Implement(interfaceType, baseObjectType, duckObject.Objects[0]));
}
// Re-aggregate underlying objects to expose new interface.
//
return(Aggregate(interfaceType, duckObject.Objects));
}
if (baseObjectType == null)
{
baseObjectType = objType;
}
else if (!TypeHelper.IsSameOrParent(baseObjectType, objType))
{
throw new ArgumentException(string.Format(Resources.DuckTyping_NotASubtypeOf, objType.FullName, baseObjectType.FullName), "obj");
}
var duckType = GetDuckType(interfaceType, baseObjectType);
if (duckType == null)
{
return(null);
}
var duck = TypeAccessor.CreateInstanceEx(duckType);
((DuckType)duck).SetObjects(obj);
return(duck);
}
public void OneThreadTest()
{
var o = TypeAccessor.CreateInstanceEx <MultiThread>();
o.Clear();
for (int i = 0; i < 10; i++)
{
o.GetValue();
}
Assert.AreEqual(1, MultiThread.Value);
}
/// <summary>
/// Implements the requested interface from supplied set of objects.
/// </summary>
/// <param name="interfaceType">An interface type to implement.</param>
/// <param name="baseObjectTypes">Array of types which have all members of the given interface.
/// When this parameter is set to null, the object type will be used.</param>
/// <param name="objs">Array of objects which types expected to have all members of the given interface.</param>
/// <returns>An object which implements the interface.</returns>
public static object Aggregate(Type interfaceType, Type[] baseObjectTypes, params object[] objs)
{
if (objs == null)
{
throw new ArgumentNullException("objs");
}
if (baseObjectTypes == null)
{
baseObjectTypes = new Type[objs.Length];
for (int i = 0; i < objs.Length; i++)
{
if (objs[i] != null)
{
baseObjectTypes[i] = objs[i].GetType();
}
}
}
else
{
if (baseObjectTypes.Length != objs.Length)
{
throw new ArgumentException(Resources.DuckTyping_InvalidNumberOfObjs, "baseObjectTypes");
}
for (int i = 0; i < objs.Length; i++)
{
Type objType = objs[i].GetType();
if (!TypeHelper.IsSameOrParent(baseObjectTypes[i], objType))
{
throw new ArgumentException(
string.Format(Resources.DuckTyping_NotASubtypeOf, objType.FullName, baseObjectTypes[i].FullName), "objs");
}
}
}
Type duckType = GetDuckType(interfaceType, baseObjectTypes);
if (duckType == null)
{
return(null);
}
object duck = TypeAccessor.CreateInstanceEx(duckType);
((DuckType)duck).SetObjects(objs);
return(duck);
}
/// <summary>
/// Initializes a new instance of the <see cref="IndexViewModel"/> class.
/// </summary>
public IndexViewModel() : base()
{
Model = HttpContext.Current.Session["Dummy"] as DummyEntity;
if (Model == null)
{
Model = TypeAccessor <DummyEntity> .CreateInstanceEx();
Model.ID = 1;
Model.DocumentDate = DateTime.Now.AddYears(-20);
Model.ChangedBy = 2877;
Model.ChangedDate = DateTime.Now.AddYears(-1);
}
HttpContext.Current.Session["Dummy"] = Model;
}
public BaseGridPanel()
{
InitializeComponent();
if (WinUtils.IsComponentInDesignMode(this))
{
return;
}
BusinessObject = TypeAccessor.CreateInstanceEx <T>();
if (Permissions != null)
{
m_ReadOnly = Permissions.IsReadOnlyForEdit;
}
Init();
}
public static T EditNew(Action <T> saveAction)
{
T entity = TypeAccessor <T> .CreateInstanceEx();
F form = new F();
form.SetBizEntity(entity);
form.Init(entity, delegate
{
saveAction(entity);
entity.AcceptChanges();
});
return(form.ShowDialog() == DialogResult.OK? entity: null);
}
/// <summary>
/// Инициализирует строго-типизированные настройки приложения.
/// </summary>
public static void Init()
{
AppSettings = TypeAccessor <TApplicationSettings> .CreateInstanceEx();
Hashtable ht = new Hashtable();
NameValueCollection settings = WebConfigurationManager.AppSettings;
foreach (string key in settings.AllKeys)
{
if (!ht.ContainsKey(key))
{
ht.Add(key, settings[key]);
}
}
Map.DictionaryToObject(ht, AppSettings);
}
public KescoGridModelBase(bool createEditActionIconsColumn, string returnUri, string key, string value)
: base(returnUri, key, value)
{
EditActionIconsColumn = null;
T model = TypeAccessor.CreateInstanceEx <T>();
Metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
Grid = new JQGrid {
Columns = CreateGridColumnDefs(),
ColumnReordering = true
};
SetUpGrid();
if (createEditActionIconsColumn)
{
CreateEditActionIconsColumn();
}
}
//[Test]
public void Test_EditableList_AcceptChanges()
{
_Person person = TypeAccessor <_Person> .CreateInstance();
person.Phones.AddRange(new _PersonPhone[]
{
TypeAccessor <_PersonPhone> .CreateInstanceEx(),
TypeAccessor <_PersonPhone> .CreateInstanceEx()
});
person.Phones[1].Number_PersonPhone = "222-22-22";
person.AcceptChanges();
Assert.IsFalse(person.IsDirty);
Assert.IsTrue(IsAcceptChangesCallForPersonPhone);
}
/// <summary>
/// Implements the requested interface for supplied object.
/// If the supplied object implements the interface, the object itself will be returned.
/// Otherwise a convenient duck object will be created.
/// </summary>
/// <param name="interfaceType">An interface type to implement.</param>
/// <param name="baseObjectType">Any type which has all members of the given interface.
/// When this parameter is set to null, the object type will be used.</param>
/// <param name="obj">An object which type has all members of the given interface.</param>
/// <returns>An object which implements the interface.</returns>
public static object Implement(Type interfaceType, Type baseObjectType, object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
Type objType = obj.GetType();
if (TypeHelper.IsSameOrParent(interfaceType, objType))
{
return(obj);
}
if (obj is DuckType)
{
// Switch to underlying object when a duck object was passed.
//
return(Implement(interfaceType, baseObjectType, ((DuckType)obj).Object));
}
if (baseObjectType == null)
{
baseObjectType = objType;
}
else if (!TypeHelper.IsSameOrParent(baseObjectType, objType))
{
throw new ArgumentException(
string.Format("'{0}' is not a subtype of '{1}'.", objType.FullName, baseObjectType.FullName), "obj");
}
Type duckType = GetDuckType(interfaceType, baseObjectType);
if (duckType == null)
{
return(null);
}
object duck = TypeAccessor.CreateInstanceEx(duckType);
((DuckType)duck).SetObject(obj);
return(duck);
}
public object AddNew()
{
if (AllowNew == false)
{
throw new NotSupportedException();
}
EndNew();
// BVChanges: adding creator
object o = null;
if (_creator != null)
{
o = _creator();
}
if (o == null)
{
o = TypeAccessor.CreateInstanceEx(_itemType);
}
// BVChanges: adding creator
_newObject = o as INotifyObjectEdit;
if (_newObject != null)
{
_newObject.ObjectEdit += NewObject_ObjectEdit;
}
_newItemIndex = _list.Add(o);
// BVChanges: adding creator
if (o is INotifyPropertyChanged)
{
((INotifyPropertyChanged)o).PropertyChanged +=
ItemPropertyChanged;
}
// BVChanges: adding creator
OnAddItem(o, _newItemIndex);
Debug.WriteLine(string.Format("AddNew - ({0})", o.GetType().Name));
return(o);
}
public T GetSaved <T>(string key, Func <T> valueFactory) where T : class
{
string uniqueKey = string.IsNullOrEmpty(key) ? GetUniqueKey(typeof(T)) : GetUniqueKey(typeof(T), key);
var obj = _storage.Get <T>(uniqueKey);
if (obj != null)
{
return(obj);
}
if (valueFactory == null)
{
valueFactory = () => TypeAccessor <T> .CreateInstanceEx();
}
_storage.Save(uniqueKey, valueFactory());
return(_storage.Get <T>(uniqueKey));
}
internal static void SetConverter(MappingSchema mappingSchema, MemberInfo member, ISqlExpression expr)
{
var sqlValue = expr as SqlValueBase;
if (sqlValue == null)
{
return;
}
var mm = mappingSchema.GetObjectMapper(member.DeclaringType)
.FirstOrDefault(_ => _.MemberName == member.Name);
if (mm == null)
{
return;
}
if (TypeHelper.IsEnumOrNullableEnum(mm.Type))
{
var memberAccessor = TypeAccessor.GetAccessor(member.DeclaringType)[member.Name];
sqlValue.SetEnumConverter(memberAccessor, mappingSchema);
}
else if (mm.IsExplicit || mm.MapMemberInfo.MapValues != null)
{
sqlValue.ValueConverter = _ =>
{
if (_ == null && mm.Type.IsValueType)
{
return(_);
}
//if (_ != null && _.GetType() != mm.MemberAccessor.Type)
// return _;
var obj = TypeAccessor.CreateInstanceEx(member.DeclaringType);
mm.MemberAccessor.SetValue(obj, _);
return(mm.GetValue(obj));
};
}
}
