public void TestGenerics() { var testTypes = new[] { typeof (TestGenericPortable<int>), typeof (TestGenericPortable<string>), typeof (TestGenericPortable<TestGenericPortable<int>>), typeof (TestGenericPortable<List<Tuple<int, string>>>), typeof (TestGenericPortable<List<TestGenericPortable<List<Tuple<int, string>>>>>), typeof (List<TestGenericPortable<List<TestGenericPortable<List<Tuple<int, string>>>>>>), typeof (TestGenericPortable<int, string>), typeof (TestGenericPortable<int, TestGenericPortable<string>>), typeof (TestGenericPortable<int, string, Type>), typeof (TestGenericPortable<int, string, TestGenericPortable<int, string, Type>>) }; foreach (var type in testTypes) { // Without assembly var resolvedType = new TypeResolver().ResolveType(type.FullName); Assert.AreEqual(type.FullName, resolvedType.FullName); // With assembly resolvedType = new TypeResolver().ResolveType(type.FullName, type.Assembly.FullName); Assert.AreEqual(type.FullName, resolvedType.FullName); // Assembly-qualified resolvedType = new TypeResolver().ResolveType(type.AssemblyQualifiedName); Assert.AreEqual(type.FullName, resolvedType.FullName); } }
/// <summary> /// Constructor. /// </summary> /// <param name="cfg">Configurtaion.</param> public PortableMarshaller(PortableConfiguration cfg) { // Validation. if (cfg == null) { cfg = new PortableConfiguration(); } if (cfg.TypeConfigurations == null) { cfg.TypeConfigurations = new List <PortableTypeConfiguration>(); } foreach (PortableTypeConfiguration typeCfg in cfg.TypeConfigurations) { if (string.IsNullOrEmpty(typeCfg.TypeName)) { throw new PortableException("Type name cannot be null or empty: " + typeCfg); } if (typeCfg.AssemblyName != null && typeCfg.AssemblyName.Length == 0) { throw new PortableException("Assembly name cannot be empty string: " + typeCfg); } } // Define predefined types. AddPredefinedType(typeof(bool), PortableUtils.TypeBool, PortableSystemHandlers.WriteHndBoolTyped, PortableSystemHandlers.WriteHndBool); AddPredefinedType(typeof(byte), PortableUtils.TypeByte, PortableSystemHandlers.WriteHndByteTyped, PortableSystemHandlers.WriteHndByte); AddPredefinedType(typeof(short), PortableUtils.TypeShort, PortableSystemHandlers.WriteHndShortTyped, PortableSystemHandlers.WriteHndShort); AddPredefinedType(typeof(char), PortableUtils.TypeChar, PortableSystemHandlers.WriteHndCharTyped, PortableSystemHandlers.WriteHndChar); AddPredefinedType(typeof(int), PortableUtils.TypeInt, PortableSystemHandlers.WriteHndIntTyped, PortableSystemHandlers.WriteHndInt); AddPredefinedType(typeof(long), PortableUtils.TypeLong, PortableSystemHandlers.WriteHndLongTyped, PortableSystemHandlers.WriteHndLong); AddPredefinedType(typeof(float), PortableUtils.TypeFloat, PortableSystemHandlers.WriteHndFloatTyped, PortableSystemHandlers.WriteHndFloat); AddPredefinedType(typeof(double), PortableUtils.TypeDouble, PortableSystemHandlers.WriteHndDoubleTyped, PortableSystemHandlers.WriteHndDouble); AddPredefinedType(typeof(string), PortableUtils.TypeString, PortableSystemHandlers.WriteHndStringTyped, PortableSystemHandlers.WriteHndString); AddPredefinedType(typeof(decimal), PortableUtils.TypeDecimal, PortableSystemHandlers.WriteHndDecimalTyped, PortableSystemHandlers.WriteHndDecimal); AddPredefinedType(typeof(DateTime), PortableUtils.TypeDate, PortableSystemHandlers.WriteHndDateTyped, PortableSystemHandlers.WriteHndDate); AddPredefinedType(typeof(Guid), PortableUtils.TypeGuid, PortableSystemHandlers.WriteHndGuidTyped, PortableSystemHandlers.WriteHndGuid); // TODO: Remove this registration AddPredefinedType(typeof(PortableUserObject), PortableUtils.TypePortable, PortableSystemHandlers.WriteHndPortableTyped, PortableSystemHandlers.WriteHndPortable); AddPredefinedType(typeof(bool[]), PortableUtils.TypeArrayBool, PortableSystemHandlers.WriteHndBoolArrayTyped, PortableSystemHandlers.WriteHndBoolArray); AddPredefinedType(typeof(byte[]), PortableUtils.TypeArrayByte, PortableSystemHandlers.WriteHndByteArrayTyped, PortableSystemHandlers.WriteHndByteArray); AddPredefinedType(typeof(short[]), PortableUtils.TypeArrayShort, PortableSystemHandlers.WriteHndShortArrayTyped, PortableSystemHandlers.WriteHndShortArray); AddPredefinedType(typeof(char[]), PortableUtils.TypeArrayChar, PortableSystemHandlers.WriteHndCharArrayTyped, PortableSystemHandlers.WriteHndCharArray); AddPredefinedType(typeof(int[]), PortableUtils.TypeArrayInt, PortableSystemHandlers.WriteHndIntArrayTyped, PortableSystemHandlers.WriteHndIntArray); AddPredefinedType(typeof(long[]), PortableUtils.TypeArrayLong, PortableSystemHandlers.WriteHndLongArrayTyped, PortableSystemHandlers.WriteHndLongArray); AddPredefinedType(typeof(float[]), PortableUtils.TypeArrayFloat, PortableSystemHandlers.WriteHndFloatArrayTyped, PortableSystemHandlers.WriteHndFloatArray); AddPredefinedType(typeof(double[]), PortableUtils.TypeArrayDouble, PortableSystemHandlers.WriteHndDoubleArrayTyped, PortableSystemHandlers.WriteHndDoubleArray); AddPredefinedType(typeof(decimal[]), PortableUtils.TypeArrayDecimal, PortableSystemHandlers.WriteHndDecimalArrayTyped, PortableSystemHandlers.WriteHndDecimalArray); AddPredefinedType(typeof(string[]), PortableUtils.TypeArrayString, PortableSystemHandlers.WriteHndStringArrayTyped, PortableSystemHandlers.WriteHndStringArray); AddPredefinedType(typeof(DateTime?[]), PortableUtils.TypeArrayDate, PortableSystemHandlers.WriteHndDateArrayTyped, PortableSystemHandlers.WriteHndDateArray); AddPredefinedType(typeof(Guid?[]), PortableUtils.TypeArrayGuid, PortableSystemHandlers.WriteHndGuidArrayTyped, PortableSystemHandlers.WriteHndGuidArray); // Define system types. They use internal reflective stuff, so configuration doesn't affect them. AddSystemTypes(); // 2. Define user types. var dfltSerializer = cfg.DefaultSerializer == null ? new PortableReflectiveSerializer() : null; var typeResolver = new TypeResolver(); ICollection <PortableTypeConfiguration> typeCfgs = cfg.TypeConfigurations; if (typeCfgs != null) { foreach (PortableTypeConfiguration typeCfg in typeCfgs) { AddUserType(cfg, typeCfg, typeResolver, dfltSerializer); } } ICollection <string> types = cfg.Types; if (types != null) { foreach (string type in types) { AddUserType(cfg, new PortableTypeConfiguration(type), typeResolver, dfltSerializer); } } if (cfg.DefaultSerializer == null) { cfg.DefaultSerializer = dfltSerializer; } _cfg = cfg; }
public void TestReferencedAssemblyLoading() { const string dllName = "Apache.Ignite.Core.Tests.TestDll"; const string typeName = "Apache.Ignite.Core.Tests.TestDll.TestClass"; // Check that the dll is not yet loaded Assert.IsFalse(AppDomain.CurrentDomain.GetAssemblies().Any(x => x.FullName.StartsWith(dllName))); // Check that the dll is referenced by current assembly Assert.IsTrue(Assembly.GetExecutingAssembly().GetReferencedAssemblies() .Any(x => x.FullName.StartsWith(dllName))); // Check resolver var type = new TypeResolver().ResolveType(typeName); Assert.IsNotNull(type); Assert.AreEqual(typeName, type.FullName); Assert.IsNotNull(Activator.CreateInstance(type)); // At this moment the dll should be loaded Assert.IsTrue(AppDomain.CurrentDomain.GetAssemblies().Any(x => x.FullName.StartsWith(dllName))); }