Esempio n. 1
0
        public T CreateProxyWithFallback <T>(T subject, T fallback)
        {
            IFallbackProxyCreator creator;

            lock (_syncRoot)
            {
                var type = typeof(T);
                if (!_fallbackProxyCreators.TryGetValue(type, out creator))
                {
                    var description = _typeModel.Add(type, assumeByReference: true);
                    creator = new FallbackProxyCreator <T>(_moduleBuilder, description);
                    _fallbackProxyCreators.Add(typeof(T), creator);
                }
            }
            return((T)creator.Create(subject, fallback));
        }
Esempio n. 2
0
        private static void ThrowIfIncompatible(Type expectedInterface, TypeModel actualTypeModel)
        {
            var expectedTypeModel   = new TypeModel();
            var expectedDescription = expectedTypeModel.Add(expectedInterface, assumeByReference: true);

            var actualDescription = actualTypeModel.Types.FirstOrDefault(x => x.AssemblyQualifiedName == expectedInterface.AssemblyQualifiedName);

            if (actualDescription == null)
            {
                throw new NotImplementedException($"The remote is missing interface: {expectedInterface.Name}");
            }

            ThrowIfIncompatible(expectedDescription, actualDescription);
        }
Esempio n. 3
0
        public TypeModel GetTypeModel()
        {
            var typeModel = new TypeModel();

            typeModel.Add <IInterfaces>(assumeByReference: true);
            typeModel.Add <IFiles>(assumeByReference: true);
            typeModel.Add <IShell>(assumeByReference: true);
            typeModel.Add <IServices>(assumeByReference: true);
            typeModel.Add <IProcesses>(assumeByReference: true);
            typeModel.Add <INetwork>(assumeByReference: true);
            typeModel.Add <IRegistry>(assumeByReference: true);
            return(typeModel);
        }
        public T GetOrAdd(Type type)
        {
            lock (_syncRoot)
            {
                // Usually we already have generated the methods necessary to serialize / deserialize
                // and thus we can simply retrieve them from the dictionary
                T serializationMethods;
                if (!_serializationMethods.TryGetValue(type, out serializationMethods))
                {
                    var typeDescription = _typeModel.Add(type);

                    // If that's not the case, then we'll have to generate them.
                    // However we need to pay special attention to certain types, for example ByReference
                    // types where the serialization method is IDENTICAL for each implementation.
                    //
                    // Usually we would call PatchType() everytime, however this method is very time-expensive
                    // and therefore we will register both the type as well as the patched type, which
                    // causes subsequent calls to RegisterType to no longer invoke PatchType.
                    //
                    // In essence PatchType is only ever invoked ONCE per type instead of for every call to RegisterType.
                    var patchedType = PatchType(type);
                    if (!_serializationMethods.TryGetValue(patchedType, out serializationMethods))
                    {
                        var typeName = BuildTypeName(type);
                        serializationMethods = _compiler.Prepare(typeName, typeDescription);

                        try
                        {
                            _serializationMethods.Add(type, serializationMethods);
                            _compiler.Compile(serializationMethods, this);
                        }
                        catch (Exception e)
                        {
                            Log.DebugFormat("Caught unexpected exception while trying to compile serialization methods for '{0}': {1}", typeDescription,
                                            e);
                            _serializationMethods.Remove(type);
                            throw;
                        }

                        if (type != patchedType)
                        {
                            _serializationMethods.Add(type, serializationMethods);
                        }
                    }
                }
                return(serializationMethods);
            }
        }