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