/// <summary> /// Delete the provided objects from the table. /// </summary> /// <typeparam name="T">Type of business object</typeparam> /// <param name="objects">Collection of objects</param> public ulong DeleteList <T>(IEnumerable <T> objects) where T : class { if (objects != null) { // we need to check if we are soft-deleting! ClassInformation?objectInfo = TypeInspector.InspectForAzureTables <T>(); if (objectInfo == null) { throw new TypeLoadException($"Type '{typeof(T).FullName}' is not anotated with the '{typeof(TableAttribute).FullName}' attribute."); } if (objectInfo.TableAttribute.UseSoftDelete) { return(UpdateInternal(objects, true)); } TableBatchOperation delete = new TableBatchOperation(); foreach (T instance in objects) { delete.Delete(AzureTableEntity.From(instance, true)); } ulong count = (ulong)delete.Count; if (count > 0) { ExecuteNonQuery <T>(delete); return(count); } } return(0L); }
/// <summary> /// Delete the provided object from the table /// </summary> /// <typeparam name="T">Type of business object</typeparam> /// <param name="item">Business object</param> /// <returns>Zero if nothing was deleted, One if the object was deleted</returns> public ulong Delete <T>(T item) where T : class { if (item != null) { // we need to check if we are soft-deleting! ClassInformation?objectInfo = TypeInspector.InspectForAzureTables <T>(); if (objectInfo == null) { throw new TypeLoadException($"Type '{typeof(T).FullName}' is not anotated with the '{typeof(TableAttribute).FullName}' attribute."); } TableAttribute tableAttribute = objectInfo.TableAttribute; AzureTableEntity entity = AzureTableEntity.From(item); TableOperation updateOrDeleteOperation; if (tableAttribute.UseSoftDelete) { entity.AddOrUpdateProperty(AzureTableEntity.PROPERTY_NAME_ISDELETED, true); updateOrDeleteOperation = TableOperation.Merge(entity); } else { updateOrDeleteOperation = TableOperation.Delete(entity); } ExecuteNonQuery <T>(updateOrDeleteOperation); return(1L); } return(0L); }
public void InspectPersonReturnsInfoWithFiveTypeMember() { var info = new TypeInspector().GetInfo(typeof(Person)); Assert.AreEqual(5, info.MemberInfoByEntityName.Count); Assert.AreEqual(5, info.MemberInfoByName.Count); }
public void DataHolderMembers_PropertyOverrides_ShouldNotCauseException() { var ti = new TypeInspector(typeof(ClassWithPropertyOverrride)); var result = ti.DataHolderMembers.ToList(); result.Count.Should().Be(1); }
public void InspectBoneReturnsInfoWithThreeTypeMembers() { var info = new TypeInspector().GetInfo(typeof(Bone)); Assert.AreEqual(3, info.MemberInfoByEntityName.Count); Assert.AreEqual(3, info.MemberInfoByName.Count); }
public void InspectOwnerReturnsInfoWithSixTypeMembers() { var info = new TypeInspector().GetInfo(typeof(Owner)); Assert.AreEqual(6, info.MemberInfoByEntityName.Count); Assert.AreEqual(6, info.MemberInfoByName.Count); }
public void Version_AdditionalProperty_ShouldBeDifferent() { var ti1 = new TypeInspector(typeof(VersionOne)); var ti2 = new TypeInspector(typeof(VersionTwo)); ti1.Version.Should().NotBe(ti2.Version); }
public void Version_DifferentGenericProperty_ShouldBeDifferent() { var ti1 = new TypeInspector(typeof(GenericOne)); var ti2 = new TypeInspector(typeof(GenericTwo)); ti1.Version.Should().NotBe(ti2.Version); }
public void GenericWithSpacesButNoName() { var result = new TypeInspector("IList<something, int>"); Assert.AreEqual("IList<something, int>", (string)result.Type); Assert.IsNull(result.Name); }
public void GenericsWithName() { var result = new TypeInspector("IList<something>\r\n\tSomethingList"); Assert.AreEqual("IList<something>", (string)result.Type); Assert.AreEqual("SomethingList", (string)result.Name); }
public void Generics() { var result = new TypeInspector("IList<something>"); Assert.AreEqual("IList<something>", (string)result.Type); Assert.IsNull(result.Name); }
public void SimpleFields() { var result = new TypeInspector("string"); Assert.AreEqual("string", (string)result.Type); Assert.IsNull(result.Name); }
public void Version_DifferentOfOpenGenericTypes_DifferentVersions() { var ti1 = new TypeInspector(typeof(GenericClass <>)); var ti2 = new TypeInspector(typeof(GenericClass2 <>)); ti1.Version.Should().NotBe(ti2.Version); }
/// <summary> /// Configures the given repository to behave as a numeric editor if /// 1: The repository derives from RepositoryItemTextEdit /// 2: The privided type is numeric (integer or double type) /// </summary> public static RepositoryItem ConfigureWith(this RepositoryItem repositoryItem, Type propertyType) { var repositoryWithMask = repositoryItem as RepositoryItemTextEdit; if (repositoryWithMask == null) { return(repositoryItem); } if (TypeInspector.IsDoubleType(propertyType)) { repositoryWithMask.Mask.MaskType = MaskType.RegEx; repositoryWithMask.Mask.EditMask = RegularExpression.Numeric; } else if (TypeInspector.IsUnsignedIntegerType(propertyType)) { repositoryWithMask.Mask.MaskType = MaskType.RegEx; repositoryWithMask.Mask.EditMask = RegularExpression.UnsignedInteger; } else if (TypeInspector.IsSignedIntegerType(propertyType)) { repositoryWithMask.Mask.MaskType = MaskType.RegEx; repositoryWithMask.Mask.EditMask = RegularExpression.Integer; } else { // nothing to do } return(repositoryWithMask); }
public void InspectDogReturnsInfoWithTenTypeMembers() { var info = new TypeInspector().GetInfo(typeof(Dog)); Assert.AreEqual(10, info.MemberInfoByEntityName.Count); Assert.AreEqual(10, info.MemberInfoByName.Count); }
public void SerializableItemCandidates_ShouldNotRecognize_DataMemberAttribute_OnStaticField() { var ti = new TypeInspector(typeof(ClassWithStaticField)); var result = ti.SerializableMemberCandidates.ToList(); result.Count.Should().Be(0); }
public void InspectInventoriedWidgetReturnsInfoWithEightTypeMembers() { var info = new TypeInspector().GetInfo(typeof(InventoriedWidget)); Assert.AreEqual("InventoriedWidget", info.EntityName); Assert.AreEqual("acme.org", info.Namespace); Assert.AreEqual(8, info.MemberInfoByEntityName.Count); Assert.AreEqual(8, info.MemberInfoByName.Count); int elements = 0; int attributes = 0; foreach (var item in info.MemberInfoByEntityName) { Assert.AreEqual(item.Value.Name == BFN("QuantityInInventory") ? 8 : 999, item.Value.Order); if (item.Value.IsAttribute) { attributes++; } else { elements++; } } Assert.AreEqual(7, attributes); Assert.AreEqual(1, elements); }
private void InitDiscovery() { if (_discoveredParts != null) { return; } var types = _configuration.DebugGetRegisteredTypes(); var defaultAttributeContext = _configuration.DebugGetDefaultAttributeContext() ?? new DirectAttributeContext(); var discovered = new List <DiscoveredPart>(); var ignored = new List <Type>(); foreach (var typeSet in types) { var ac = typeSet.Item2 ?? defaultAttributeContext; var activationFeatures = TypedPartExportDescriptorProvider.DebugGetActivationFeatures(ac); var inspector = new TypeInspector(ac, activationFeatures); foreach (var type in typeSet.Item1) { DiscoveredPart part; if (inspector.InspectTypeForPart(type.GetTypeInfo(), out part)) { discovered.Add(part); } else { ignored.Add(type); } } } _discoveredParts = discovered.ToArray(); _ignoredTypes = ignored.ToArray(); }
/// <summary> /// Writes a single element record to the stream. This method does NOT write out the header row! /// </summary> /// <typeparam name="T">Type of business object</typeparam> /// <param name="instances">Instance of business object to write</param> /// <param name="writeHeader">We will write out the header ONLY if this is TRUE. Default: FALSE</param> public void WriteRecords <T>(IEnumerable <T> instances, bool writeHeader = false) where T : class, new() { ClassInfo objectInfo = TypeInspector.InspectOnlyMembersAnotated <T, FileFieldAttribute>(); string[] headers = GetHeader <T>(objectInfo); if (writeHeader) { for (int h = 0; h < headers.Length; h++) { string element = headers[h]; if (element != null) { writer.Write("\""); writer.Write(element); writer.Write("\""); } if (h < (headers.Length - 1)) { writer.Write(DELIMITER); } } writer.WriteLine(); } foreach (T instance in instances) { WriteElements(GetRecord(instance, headers, objectInfo)); } writer.Flush(); }
public void SerializableItemCandidates_ShouldRecognize_DataMemberAttribute_OnBaseClasses() { var ti = new TypeInspector(typeof(DerivedClassWithFields)); var result = ti.SerializableMemberCandidates.ToList(); result.Count.Should().Be(2); }
public void SerializableItemCandidates_ShouldRecognize_DataMemberAttribute_OnPrivateProperty() { var ti = new TypeInspector(typeof(ClassWithPrivateProperty)); var result = ti.SerializableMemberCandidates.ToList(); result.Count.Should().Be(1); result[0].Name.Should().Be("Property"); }
public void SerializableItemCandidates_ContainsBaseClassPrivateFieldsAndPropertiesToo() { var typeInspector = new TypeInspector(typeof(MyClass)); var items = typeInspector.SerializableMemberCandidates.ToList(); items.Should().Contain(i => i.Name == "_myField"); items.Should().Contain(i => i.Name == "MyProperty"); }
public void GivenAType_WhenSearchingForTypeHierarchy_ShouldReturnBaseTypesAndInputType(Type input, IEnumerable <Type> expectedResult) { var inspector = new TypeInspector(); var result = inspector.GetTypeHierarchy(input); CollectionAssert.AreEqual(expectedResult, result); }
public void TestGetFieldOffsets() { Console.WriteLine( string.Join("\r\n", TypeInspector.GetFieldOffsets(typeof(ByteAndInt)) .Select(tpl => $"Field {tpl.fieldInfo.Name}: starts at offset {tpl.offset}")) ); }
public void GivenAType_WhenSearchingForTypeHierarchy_ShouldReturnBaseTypesAndInputType(Type input, IEnumerable<Type> expectedResult) { var inspector = new TypeInspector(); var result = inspector.GetTypeHierarchy(input); CollectionAssert.AreEqual(expectedResult, result); }
public InstanceRecipientInvoker( TypeInspector inspector, IRecipientFactory factory, CollisionStrategy collisionStrategy) { _inspector = inspector; _factory = factory; _collisionStrategy = collisionStrategy; }
/// <summary> /// Writes a single element record to the stream. This method does NOT write out the header row! /// </summary> /// <typeparam name="T">Type of business object</typeparam> /// <param name="instance">Instance of business object to write</param> public void WriteRecord <T>(T instance) where T : class, new() { ClassInfo objectInfo = TypeInspector.InspectOnlyMembersAnotated <T, FileFieldAttribute>(); string[] headers = GetHeader <T>(objectInfo); WriteElements(GetRecord(instance, headers, objectInfo)); }
public void InspectHazardousWidgetReturnsInfoWithSixTypeMembers() { var info = new TypeInspector().GetInfo(typeof(HazardousWidget)); Assert.AreEqual("Widget", info.EntityName); Assert.AreEqual("acme.org", info.Namespace); Assert.AreEqual(6, info.MemberInfoByEntityName.Count); Assert.AreEqual(6, info.MemberInfoByName.Count); }
public void GlobalSetup() { _log.Debug("setup"); var assemblyPath = @"MindTouch.Deki.Util.Tests.dll"; _inspector = new TypeInspector(); _inspector.InspectAssembly(assemblyPath); _xmlDocumentation = XDocFactory.LoadFrom(@"MindTouch.Deki.Util.Tests.xml", MimeType.TEXT_XML); }
public void InspectSellableWidgetReturnsInfoWithTenTypeMembers() { var info = new TypeInspector().GetInfo(typeof(SellableWidget)); Assert.AreEqual("SaleWidget", info.EntityName); Assert.AreEqual("acme.net", info.Namespace); Assert.AreEqual(10, info.MemberInfoByEntityName.Count); Assert.AreEqual(10, info.MemberInfoByName.Count); }
public void Can_inspect_dream_without_appdomain() { _log.Debug("starting dream inspection"); var inspector = new TypeInspector(); inspector.InspectAssembly(@"mindtouch.dream.dll"); inspector.InspectAssembly(@"mindtouch.dream.test.dll"); inspector.InspectAssembly(@"mindtouch.core.dll"); var types = inspector.Types.ToList(); }
public static TypeInspector Inspector(this Type type) { TypeInspector inspector; if (!_typeInspectorCache.Value.TryGetValue(type, out inspector)) { inspector = new TypeInspector(type); _typeInspectorCache.Value[type] = inspector; } return inspector; }
/// <summary> /// Returns the Apply methods for each type in the event type's inheritance /// hierarchy, top-down, from interfaces before classes. /// </summary> private IEnumerable<MethodInfo> FindApplyMethods(object evt) { var typeInspector = new TypeInspector(); var applyMethods = typeInspector.GetTypeHierarchy(evt.GetType()) .Select(FindApplyMethod) .Where(x => x != null) .ToList(); return applyMethods; }