protected void OnEnnemyKill()
{
if (onEnnemyKillFunction != "")
{
ClassReflector.DynamicInvoke(quest, onEnnemyKillFunction, ennemyController);
}
}
public void ClassReflector_CreatesBaseClass_CompatibleWithDerivedInstances_WithMixins_WithOverriddenProperty()
{
using (MixinConfiguration.BuildNew()
.ForClass <BaseBusinessObjectClass> ().AddMixin <MixinOverridingProperty> ()
.ForClass <BaseBusinessObjectClass> ().AddMixin <BindableObjectMixin> ()
.EnterScope())
{
var classReflector = new ClassReflector(
typeof(BaseBusinessObjectClass),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
var bindableObjectClass = classReflector.GetMetadata();
var derivedBusinessObject = ObjectFactory.Create <DerivedBusinessObjectClass> (ParamList.Empty);
derivedBusinessObject.Public = "p";
Mixin.Get <MixinOverridingProperty> (derivedBusinessObject).Public += "q";
var propertyDefinition = bindableObjectClass.GetPropertyDefinition("Public");
Assert.That(propertyDefinition, Is.Not.Null);
var businessObject = (IBusinessObject)derivedBusinessObject;
Assert.That(businessObject.GetProperty(propertyDefinition), Is.EqualTo("pq"));
}
}
public void GetMetadata_ForSealedBusinessObject_WithExistingMixin()
{
var mixinTargetType = typeof(ManualBusinessObject);
var businessObjectType = typeof(SealedBindableObject);
Assertion.IsTrue(mixinTargetType.IsAssignableFrom(businessObjectType));
using (MixinConfiguration.BuildNew()
.AddMixinToClass(
MixinKind.Extending,
mixinTargetType,
typeof(MixinStub),
MemberVisibility.Public,
Enumerable.Empty <Type>(),
Enumerable.Empty <Type>())
.EnterScope())
{
var classReflector = new ClassReflector(
businessObjectType,
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
var bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass, Is.InstanceOf(typeof(IBusinessObjectClass)));
Assert.That(bindableObjectClass.TargetType, Is.SameAs(businessObjectType));
Assert.That(bindableObjectClass.ConcreteType, Is.SameAs(bindableObjectClass.TargetType));
}
}
public void Initialize()
{
IClassReflector classReflector = new ClassReflector(_type, _businessObjectProvider, _metadataFactory, _bindableObjectGlobalizationService);
Assert.That(classReflector.TargetType, Is.SameAs(_type));
Assert.That(((ClassReflector)classReflector).ConcreteType, Is.Not.SameAs(_type));
Assert.That(((ClassReflector)classReflector).ConcreteType, Is.SameAs(MixinTypeUtility.GetConcreteMixedType(_type)));
Assert.That(classReflector.BusinessObjectProvider, Is.SameAs(_businessObjectProvider));
}
public void GetMetadata_ForTypeWithoutBusinessObjectInterface()
{
var classReflector = new ClassReflector(
typeof(SimpleReferenceType),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
classReflector.GetMetadata();
}
public void GetMetadata_ForMixedPropertyWithSameName()
{
var classReflector = new ClassReflector(
typeof(ClassWithMixedPropertyOfSameName),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
classReflector.GetMetadata();
}
public void HasPropertyDefinition_ForMixedProperty()
{
var classReflector = new ClassReflector(
typeof(ClassWithMixedProperty),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.HasPropertyDefinition("MixedProperty"), Is.True);
}
public void GetPropertyDefinition_WithInvalidPropertyName()
{
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.GetPropertyDefinition("Invalid"), Is.Null);
}
public void HasPropertyDefinition()
{
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.HasPropertyDefinition("String"), Is.True);
Assert.That(bindableObjectClass.HasPropertyDefinition("Invalid"), Is.False);
}
public void GetMetadata_ForBindableObjectWithManualIdentity()
{
var classReflector = new ClassReflector(
typeof(ClassWithManualIdentity),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
var bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass, Is.InstanceOf(typeof(IBusinessObjectClassWithIdentity)));
Assert.That(bindableObjectClass.TargetType, Is.SameAs(typeof(ClassWithManualIdentity)));
}
public void GetMetadata_ForValueType()
{
var classReflector = new ClassReflector(
typeof(ValueTypeBindableObject),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
var bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass, Is.InstanceOf(typeof(IBusinessObjectClass)));
Assert.That(bindableObjectClass.TargetType, Is.SameAs(typeof(ValueTypeBindableObject)));
Assert.That(bindableObjectClass.ConcreteType, Is.SameAs(bindableObjectClass.TargetType));
}
public void GetMetadataFromCache()
{
ClassReflector reflector = new ClassReflector();
SecurableClassInfo paperFileInfo = reflector.GetMetadata(typeof(PaperFile), _cache);
Assert.That(paperFileInfo, Is.Not.Null);
Assert.That(_cache.GetSecurableClassInfo(typeof(PaperFile)), Is.EqualTo(paperFileInfo));
SecurableClassInfo fileInfo = _cache.GetSecurableClassInfo(typeof(File));
Assert.That(fileInfo, Is.Not.Null);
Assert.That(fileInfo.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.File, Remotion.Security.UnitTests.TestDomain"));
}
public void GetPropertyDefinition()
{
PropertyReflector propertyReflector =
PropertyReflector.Create(GetPropertyInfo(typeof(SimpleBusinessObjectClass), "String"), _bindableObjectProvider);
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
CheckPropertyBase(propertyReflector.GetMetadata(), bindableObjectClass.GetPropertyDefinition("String"));
}
public void ExecuteOnDialogClose()
{
if (onDialogCloseFunction != "" && ClassReflector.HasMethod(quest, onDialogCloseFunction))
{
ClassReflector.DynamicInvoke(quest, onDialogCloseFunction, this);
}
if (stepStateToRegisterOnDialogClose != null)
{
stepStateToRegisterOnDialogClose.Register();
}
hasRead = true;
}
public void GetMetadata()
{
var classReflector = new ClassReflector(_type, _businessObjectProvider, _metadataFactory, _bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass, Is.InstanceOf(typeof(IBusinessObjectClass)));
Assert.That(bindableObjectClass.TargetType, Is.SameAs(_type));
Assert.That(bindableObjectClass.GetPropertyDefinitions().Length, Is.EqualTo(1));
Assert.That(bindableObjectClass.GetPropertyDefinitions()[0].Identifier, Is.EqualTo("Public"));
Assert.That(
((PropertyBase)bindableObjectClass.GetPropertyDefinitions()[0]).PropertyInfo.DeclaringType,
Is.SameAs(TypeAdapter.Create(_type)));
Assert.That(bindableObjectClass.GetPropertyDefinitions()[0].BusinessObjectProvider, Is.SameAs(_businessObjectProvider));
}
public ClassDefinition CreateClassDefinition(Type type, ClassDefinition baseClass)
{
ArgumentUtility.CheckNotNull("type", type);
var classReflector = new ClassReflector(
type,
this,
_nameResolver,
_classIDProvider,
_propertyMetadataProvider,
_domainModelConstraintProvider,
_instanceCreator);
return(classReflector.GetMetadata(baseClass));
}
public void GetPropertyDefinitions()
{
Type type = typeof(ClassWithReferenceType <SimpleReferenceType>);
var expectedProperties = new[]
{
CreateProperty(type, "Scalar"),
CreateProperty(type, "ReadOnlyScalar"),
CreateProperty(type, "ReadOnlyAttributeScalar"),
CreateProperty(type, "ReadOnlyNonPublicSetterScalar"),
CreateProperty(type, "Array"),
CreateProperty(type, "ImplicitInterfaceScalar"),
CreateProperty(type, "ImplicitInterfaceReadOnlyScalar"),
CreateProperty(
type,
"Remotion.ObjectBinding.UnitTests.TestDomain.IInterfaceWithReferenceType<T>.ExplicitInterfaceScalar")
,
CreateProperty(
type,
"Remotion.ObjectBinding.UnitTests.TestDomain.IInterfaceWithReferenceType<T>.ExplicitInterfaceReadOnlyScalar"),
CreateProperty(type, "PropertyWithNoSetter"),
CreateProperty(type, "ThrowingProperty"),
};
var classReflector = new ClassReflector(
type,
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
IBusinessObjectProperty[] actualProperties = bindableObjectClass.GetPropertyDefinitions();
Assert.That(actualProperties.Length, Is.EqualTo(expectedProperties.Length));
foreach (PropertyBase expectedProperty in expectedProperties)
{
bool isFound = false;
foreach (IBusinessObjectProperty actualProperty in actualProperties)
{
if (actualProperty.Identifier == expectedProperty.Identifier)
{
Assert.That(isFound, Is.False, "Multiple properties '{0}' found", expectedProperty.Identifier, BindableObjectMetadataFactory.Create());
CheckPropertyBase(expectedProperty, actualProperty);
isFound = true;
}
}
Assert.That(isFound, Is.True, "Property '{0}' was not found", expectedProperty.Identifier);
}
}
public void SetUp()
{
_mocks = new MockRepository();
_statePropertyReflectorMock = _mocks.StrictMock <IStatePropertyReflector> ();
_accessTypeReflectorMock = _mocks.StrictMock <IAccessTypeReflector> ();
_classReflector = new ClassReflector(_statePropertyReflectorMock, _accessTypeReflectorMock);
_cache = new MetadataCache();
_confidentialityProperty = new StatePropertyInfo();
_confidentialityProperty.ID = Guid.NewGuid().ToString();
_confidentialityProperty.Name = "Confidentiality";
_stateProperty = new StatePropertyInfo();
_stateProperty.ID = Guid.NewGuid().ToString();
_stateProperty.Name = "State";
}
public void GetPropertyDefinition_ForMixedProperty()
{
PropertyReflector propertyReflector = PropertyReflector.Create(
GetPropertyInfo(
MixinTypeUtility.GetConcreteMixedType(typeof(ClassWithMixedProperty)),
typeof(IMixinAddingProperty).FullName + ".MixedProperty"),
_bindableObjectProvider);
var classReflector = new ClassReflector(
typeof(ClassWithMixedProperty),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
CheckPropertyBase(propertyReflector.GetMetadata(), bindableObjectClass.GetPropertyDefinition("MixedProperty"));
}
public void ClassReflector_CreatesBaseClass_CompatibleWithDerivedInstances()
{
var classReflector = new ClassReflector(
typeof(BaseBusinessObjectClass),
_businessObjectProvider,
_metadataFactory,
_bindableObjectGlobalizationService);
var bindableObjectClass = classReflector.GetMetadata();
var derivedBusinessObject = ObjectFactory.Create <DerivedBusinessObjectClass> (ParamList.Empty);
((BaseBusinessObjectClass)derivedBusinessObject).Public = "p";
var propertyDefinition = bindableObjectClass.GetPropertyDefinition("Public");
var businessObject = (IBusinessObject)derivedBusinessObject;
Assert.That(businessObject.GetProperty(propertyDefinition), Is.EqualTo("p"));
}
public void LoadStepState(StepStateHolder stepStateHolder)
{
if (CompletedStepStates.ContainsKey(Helper.GetObjectLocalIdInFile(stepStateHolder)))
{
string methodName = "LoadStepState" + Helper.UcFirst(stepStateHolder.StepStateSlug);
if (ClassReflector.HasMethod(this, methodName))
{
ClassReflector.DynamicInvoke(this, methodName, stepStateHolder);
}
else
{
throw new System.Exception("The method " + methodName + " doesn't exist in the current class.");
}
}
}
public override void SetUp()
{
base.SetUp();
_businessObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory();
_bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>();
ClassReflector classReflector = new ClassReflector(
typeof(ClassWithValueType <bool>),
_businessObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
_businessObjectClass = classReflector.GetMetadata();
_mockRepository = new MockRepository();
}
public bool IsStepReachable()
{
if (reachConditionName == "")
{
return(true);
}
else if (ClassReflector.HasProperty(quest, reachConditionName))
{
return(ClassReflector.GetBoolProperty(quest, reachConditionName));
}
else if (ClassReflector.HasMethod(quest, reachConditionName))
{
return(ClassReflector.DynamicInvokeBool(quest, reachConditionName, this));
}
else
{
throw new System.Exception("The given reachConditionName (" + reachConditionName + ") isn't an existing property or method in the associated quest.");
}
}
public void GetMetadata_UsesFactory()
{
var mockRepository = new MockRepository();
var factoryMock = mockRepository.StrictMock <IMetadataFactory> ();
IPropertyInformation dummyProperty1 = GetPropertyInfo(typeof(DateTime), "Now");
IPropertyInformation dummyProperty2 = GetPropertyInfo(typeof(Environment), "TickCount");
PropertyReflector dummyReflector1 = PropertyReflector.Create(GetPropertyInfo(typeof(DateTime), "Ticks"), _businessObjectProvider);
PropertyReflector dummyReflector2 = PropertyReflector.Create(GetPropertyInfo(typeof(Environment), "NewLine"), _businessObjectProvider);
var propertyFinderMock = mockRepository.StrictMock <IPropertyFinder> ();
var otherClassReflector = new ClassReflector(
_type,
_businessObjectProvider,
factoryMock,
_bindableObjectGlobalizationService);
Type concreteType = MixinTypeUtility.GetConcreteMixedType(_type);
Expect.Call(factoryMock.CreatePropertyFinder(concreteType)).Return(propertyFinderMock);
Expect.Call(propertyFinderMock.GetPropertyInfos()).Return(new[] { dummyProperty1, dummyProperty2 });
Expect.Call(factoryMock.CreatePropertyReflector(concreteType, dummyProperty1, _businessObjectProvider)).Return(dummyReflector1);
Expect.Call(factoryMock.CreatePropertyReflector(concreteType, dummyProperty2, _businessObjectProvider)).Return(dummyReflector2);
mockRepository.ReplayAll();
BindableObjectClass theClass = otherClassReflector.GetMetadata();
Assert.That(theClass.GetPropertyDefinition("Ticks"), Is.Not.Null);
Assert.That(theClass.GetPropertyDefinition("NewLine"), Is.Not.Null);
Assert.That(theClass.GetPropertyDefinition("Now"), Is.Null);
Assert.That(theClass.GetPropertyDefinition("TickCount"), Is.Null);
mockRepository.VerifyAll();
}
public void GetDisplayName_WithGlobalizationService()
{
var mockMemberInformationGlobalizationService = _mockRepository.StrictMock <IMemberInformationGlobalizationService> ();
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
new BindableObjectGlobalizationService(
MockRepository.GenerateStub <IGlobalizationService>(),
mockMemberInformationGlobalizationService,
MockRepository.GenerateStub <IEnumerationGlobalizationService>(),
MockRepository.GenerateStub <IExtensibleEnumGlobalizationService>()));
var bindableObjectClass = classReflector.GetMetadata();
Expect.Call(
mockMemberInformationGlobalizationService.TryGetTypeDisplayName(
Arg <ITypeInformation> .Matches(c => c.ConvertToRuntimeType() == bindableObjectClass.TargetType),
Arg <ITypeInformation> .Matches(c => c.ConvertToRuntimeType() == bindableObjectClass.TargetType),
out Arg <string> .Out("MockString").Dummy))
.Return(true);
_mockRepository.ReplayAll();
Assert.That(bindableObjectClass.GetDisplayName(), Is.EqualTo("MockString"));
}
public static void Generate(string fileName, string namespaceToSearch, string directoryName, bool forceAttribute)
{
string[] files = Directory.GetFiles(Path.GetDirectoryName(fileName), "*.dll");
string targetPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
foreach (string file in files)
{
if (!File.Exists(Path.Combine(targetPath, Path.GetFileName(file))))
{
File.Copy(file, Path.Combine(targetPath, Path.GetFileName(file)));
}
}
Assembly assembly = Assembly.LoadFile(fileName);
List <string> classes = AssemblyReflector.ListClasses(assembly);
Console.WriteLine("Directory is " + directoryName);
// Search for this namespace
string regexFind = "^" + namespaceToSearch.Replace(".", @"\.") + @"\.\w+$";
foreach (string orgClassName in classes)
{
try
{
// Ignore classes that doesn't exist in the given namespace
if (!Regex.Match(orgClassName, regexFind).Success)
{
Console.WriteLine(" Skip " + orgClassName); // togr
continue;
}
Type orgType = assembly.GetType(orgClassName);
Class reflectClass = ClassReflector.ReflectType(orgType, forceAttribute);
if (reflectClass == null)
{
Console.WriteLine(" Skip2 " + orgClassName); // togr
continue;
}
Console.WriteLine(" Generate " + orgClassName); // togr
string hibernateMap = HibernateMapGenerator.Generate(reflectClass);
string shortFileName = string.Format(@"{0}.hbm.xml", reflectClass.Type.Name);
string outputFileName = string.Format(@"{0}\{1}", directoryName, shortFileName);
bool writeFile = true;
Console.WriteLine("file is " + outputFileName);
// Check if outputfile exist
if (File.Exists(outputFileName))
{
// Read contents
string existingContent = File.ReadAllText(outputFileName, Encoding.UTF8);
// Check if contents have changed
if (existingContent == hibernateMap)
{
writeFile = false;
}
}
if (writeFile)
{
try
{
if (File.Exists(outputFileName))
{
// Set attributes to Archive because file could be readonly
File.SetAttributes(outputFileName, FileAttributes.Archive);
}
// Write the file to disc
StreamWriter w = new StreamWriter(outputFileName, false, Encoding.UTF8);
w.Write(hibernateMap);
w.Close();
Console.WriteLine("Created file {0}", shortFileName);
}
catch (Exception ex)
{
Console.WriteLine("Failed to create file {0} with exception {1}", shortFileName, ex);
}
}
}
catch (Exception outerEx)
{
Console.WriteLine("Failed to generate code for class {0} with exception {1}", orgClassName, outerEx);
}
}
Console.WriteLine("Done!");
}