示例#1
0
 /// <summary>
 /// Adds additionaly type information.
 /// </summary>
 /// <param name="typeMapping">The new type mapping.</param>
 public void AddTypeInfo(TypeMapping typeMapping)
 {
     if (typeIds.ContainsKey(typeMapping.Id))
     {
         return;
     }
     try {
         Type type = TypeLoader.Load(typeMapping.TypeName);
         typeIds.Add(typeMapping.Id, type);
         Type   serializerType = TypeLoader.Load(typeMapping.Serializer);
         object serializer;
         if (serializerInstances.ContainsKey(serializerType))
         {
             serializer = serializerInstances[serializerType];
         }
         else
         {
             serializer = Activator.CreateInstance(serializerType, true);
             serializerInstances.Add(serializerType, serializer);
         }
         serializerMapping.Add(type, serializer);
     } catch (PersistenceException) {
         throw;
     } catch (Exception e) {
         throw new PersistenceException(string.Format(
                                            "Could not add type info for {0} ({1})",
                                            typeMapping.TypeName, typeMapping.Serializer), e);
     }
 }
示例#2
0
 internal static Type?NewResourceHandlerTypeFor(string?resourceHandlerTypeName)
 {
     try
     {
         Type?resourceHandlerClass = TypeLoader.Load(resourceHandlerTypeName);
         if (resourceHandlerClass == null)
         {
             if (TryLoadAlreadyGeneratedAssembly(resourceHandlerTypeName, out var assembly))
             {
                 try
                 {
                     resourceHandlerClass = assembly?.GetType(resourceHandlerTypeName !, true);
                 }
                 catch (Exception)
                 {
                     resourceHandlerClass = Assembly.GetCallingAssembly().GetType(resourceHandlerTypeName !, true);
                 }
             }
             else
             {
                 resourceHandlerClass = Assembly.GetCallingAssembly().GetType(resourceHandlerTypeName !, true);
             }
         }
         ConfirmResourceHandler(resourceHandlerClass);
         return(resourceHandlerClass);
     }
     catch (Exception e)
     {
         throw new ArgumentException($"The resource handler class {resourceHandlerTypeName} cannot be loaded because: {e.Message}");
     }
 }
示例#3
0
        public void NoTypeNamePicksFirstType()
        {
            Type   forwardingLoggerType                      = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger);
            string forwardingLoggerAssemblyLocation          = forwardingLoggerType.Assembly.Location;
            Func <Type, object, bool> forwardingLoggerfilter = IsForwardingLoggerClass;
            Type firstPublicType = FirstPublicDesiredType(forwardingLoggerfilter, forwardingLoggerAssemblyLocation);

            TypeLoader loader     = new TypeLoader(forwardingLoggerfilter);
            LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation));

            Assert.NotNull(loadedType);
            Assert.True(loadedType.Assembly.AssemblyLocation.Equals(forwardingLoggerAssemblyLocation, StringComparison.OrdinalIgnoreCase));
            Assert.True(loadedType.Type.Equals(firstPublicType));


            Type   fileLoggerType                      = typeof(Microsoft.Build.Logging.FileLogger);
            string fileLoggerAssemblyLocation          = forwardingLoggerType.Assembly.Location;
            Func <Type, object, bool> fileLoggerfilter = IsLoggerClass;

            firstPublicType = FirstPublicDesiredType(fileLoggerfilter, fileLoggerAssemblyLocation);

            loader     = new TypeLoader(fileLoggerfilter);
            loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation));
            Assert.NotNull(loadedType);
            Assert.True(loadedType.Assembly.AssemblyLocation.Equals(fileLoggerAssemblyLocation, StringComparison.OrdinalIgnoreCase));
            Assert.True(loadedType.Type.Equals(firstPublicType));
        }
示例#4
0
        public void NoTypeNamePicksFirstType()
        {
            Type   forwardingLoggerType                      = typeof(net.r_eg.IeXod.Logging.ConfigurableForwardingLogger);
            string forwardingLoggerAssemblyLocation          = forwardingLoggerType.Assembly.Location;
            Func <Type, object, bool> forwardingLoggerfilter = IsForwardingLoggerClass;
            Type firstPublicType = FirstPublicDesiredType(forwardingLoggerfilter, forwardingLoggerAssemblyLocation);

            TypeLoader loader     = new TypeLoader(forwardingLoggerfilter);
            LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation));

            Assert.NotNull(loadedType);
            Assert.Equal(forwardingLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
            Assert.Equal(firstPublicType, loadedType.Type);


            Type   fileLoggerType                      = typeof(net.r_eg.IeXod.Logging.FileLogger);
            string fileLoggerAssemblyLocation          = forwardingLoggerType.Assembly.Location;
            Func <Type, object, bool> fileLoggerfilter = IsLoggerClass;

            firstPublicType = FirstPublicDesiredType(fileLoggerfilter, fileLoggerAssemblyLocation);

            loader     = new TypeLoader(fileLoggerfilter);
            loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation));
            Assert.NotNull(loadedType);
            Assert.Equal(fileLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
            Assert.Equal(firstPublicType, loadedType.Type);
        }
示例#5
0
 private static Type ActorClassWithProtocol(string?actorClassname, Type protocolClass)
 {
     try
     {
         var actorClass = TypeLoader.Load(actorClassname);
         AssertActorWithProtocol(actorClass, protocolClass);
         return(actorClass);
     }
     catch (Exception e)
     {
         throw new ArgumentException($"The class {actorClassname} cannot be loaded because: {e.Message}", e);
     }
 }
示例#6
0
        public void TypeLoader_ShouldLoadModule_WhenValidTypeNameIsProvided()
        {
            // Given
            var types = new string[]
            {
                "Test.Extensible.Module.TestModule, Test.Extensible.Module"
            };
            var loader = new TypeLoader <TestAppEvents>(types);

            // When
            var modules = loader.Load(new TestAppEvents());

            // Then
            Assert.Single(modules);
        }
示例#7
0
        public void TypeLoader_ShouldNotBindEvents_WhenNoValidTypeNamesAreProvided()
        {
            // Given
            var types = new string[]
            {
            };
            var loader = new TypeLoader <TestAppEvents>(types);
            var events = new TestAppEvents();

            // When
            var modules = loader.Load(events);

            //Then
            Assert.Null(events.MyEvent);
        }
示例#8
0
        public void Regress640476PartialName()
        {
            string     forwardingLoggerLocation = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger).Assembly.Location;
            TypeLoader loader     = new TypeLoader(IsForwardingLoggerClass);
            LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation));

            Assert.NotNull(loadedType);
            Assert.True(loadedType.Assembly.AssemblyLocation.Equals(forwardingLoggerLocation, StringComparison.OrdinalIgnoreCase));

            string fileLoggerLocation = typeof(Microsoft.Build.Logging.FileLogger).Assembly.Location;

            loader     = new TypeLoader(IsLoggerClass);
            loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation));
            Assert.NotNull(loadedType);
            Assert.True(loadedType.Assembly.AssemblyLocation.Equals(fileLoggerLocation, StringComparison.OrdinalIgnoreCase));
        }
示例#9
0
        public void Regress640476PartialName()
        {
            string     forwardingLoggerLocation = typeof(net.r_eg.IeXod.Logging.ConfigurableForwardingLogger).Assembly.Location;
            TypeLoader loader     = new TypeLoader(IsForwardingLoggerClass);
            LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation));

            Assert.NotNull(loadedType);
            Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);

            string fileLoggerLocation = typeof(net.r_eg.IeXod.Logging.FileLogger).Assembly.Location;

            loader     = new TypeLoader(IsLoggerClass);
            loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation));
            Assert.NotNull(loadedType);
            Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
        }
示例#10
0
        public void TypeLoader_ShouldBindEvents_WhenValidTypeNameIsProvided()
        {
            // Given
            var types = new string[]
            {
                "Test.Extensible.Module.TestModule, Test.Extensible.Module"
            };
            var loader = new TypeLoader <TestAppEvents>(types);
            var events = new TestAppEvents();

            // When
            var modules = loader.Load(events);

            //Then
            Assert.NotNull(events.MyEvent);
        }
示例#11
0
        public void TypeLoader_ShouldLoadModules_WhenMultipleTypeNamesProvided()
        {
            // Given
            var types = new string[]
            {
                "Test.Extensible.Module.TestModule, Test.Extensible.Module",
                "Test.Extensible.ModuleLoaders.TestTypeModule, Test.Extensible"
            };
            var loader = new TypeLoader <TestAppEvents>(types);

            // When
            var modules = loader.Load(new TestAppEvents());

            // Then
            Assert.Equal(2, modules.Count());
        }
示例#12
0
        public void Regress640476FullyQualifiedName()
        {
            Type       forwardingLoggerType     = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger);
            string     forwardingLoggerLocation = forwardingLoggerType.Assembly.Location;
            TypeLoader loader     = new TypeLoader(IsForwardingLoggerClass);
            LoadedType loadedType = loader.Load(forwardingLoggerType.FullName, AssemblyLoadInfo.Create(null, forwardingLoggerLocation));

            Assert.NotNull(loadedType);
            Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);

            Type   fileLoggerType     = typeof(Microsoft.Build.Logging.FileLogger);
            string fileLoggerLocation = fileLoggerType.Assembly.Location;

            loader     = new TypeLoader(IsLoggerClass);
            loadedType = loader.Load(fileLoggerType.FullName, AssemblyLoadInfo.Create(null, fileLoggerLocation));
            Assert.NotNull(loadedType);
            Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
        }
示例#13
0
        private void WriteDataContext(CodeWriter writer, Database schema, GenerationContext context)
        {
            if (schema.Tables.Count == 0)
            {
                writer.WriteCommentLine("L69 no tables found");
                return;
            }


            string contextBase     = schema.BaseType;
            var    contextBaseType = TypeLoader.Load(contextBase);

            // if we don't specify a base type, use the default
            if (string.IsNullOrEmpty(contextBase))
            {
                contextBaseType = typeof(DataContext);
            }
            // in all cases, get the literal type name from loaded type
            contextBase = writer.GetLiteralType(contextBaseType);

            var specifications = SpecificationDefinition.Partial;

            if (schema.AccessModifierSpecified)
            {
                specifications |= GetSpecificationDefinition(schema.AccessModifier);
            }
            else
            {
                specifications |= SpecificationDefinition.Public;
            }
            if (schema.ModifierSpecified)
            {
                specifications |= GetSpecificationDefinition(schema.Modifier);
            }
            using (writer.WriteClass(specifications, schema.Class, contextBase))
            {
                WriteDataContextExtensibilityDeclarations(writer, schema, context);
                WriteDataContextCtors(writer, schema, contextBaseType, context);
                WriteDataContextTables(writer, schema, context);
                WriteDataContextProcedures(writer, schema, context);
            }
        }
示例#14
0
 public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
   IEnumerator<Tag> it = metaInfo.GetEnumerator();
   try {
     it.MoveNext();
   }
   catch (InvalidOperationException e) {
     throw new PersistenceException("Insufficient meta information to instantiate Type object", e);
   }
   try {
     return TypeLoader.Load((string)it.Current.Value);
   }
   catch (InvalidCastException e) {
     throw new PersistenceException("Invalid meta information during reconstruction of Type object", e);
   }
   catch (TypeLoadException e) {
     throw new PersistenceException(String.Format(
       "Cannot load Type {0}, make sure all required assemblies are available.",
       (string)it.Current.Value), e);
   }
 }
示例#15
0
        private Tuple <string, IList <MethodParameter> > Parse(string?to)
        {
            var bad = $"Invalid to declaration: {to}";

            var openParen  = to?.IndexOf("(");
            var closeParen = to?.LastIndexOf(")");

            if (!openParen.HasValue || openParen < 0 || !closeParen.HasValue || closeParen < 0)
            {
                throw new InvalidOperationException(bad);
            }

            var methodName    = to?.Substring(0, openParen.Value);
            var rawParameters = to?.Substring(openParen.Value + 1, closeParen.Value - (openParen.Value + 1)).Split(',');
            var parameters    = new List <MethodParameter>(rawParameters !.Length);

            foreach (var p in rawParameters)
            {
                var rawParameter = p.Trim();
                if (!string.IsNullOrEmpty(rawParameter))
                {
                    if (rawParameter.StartsWith("body:"))
                    {
                        var body = TypeAndName(rawParameter.Substring(5));
                        parameters.Add(new MethodParameter(body[0], body[1], TypeLoader.Load(QualifiedType(body[0]))));
                    }
                    else
                    {
                        var other = TypeAndName(rawParameter);
                        parameters.Add(new MethodParameter(other[0], other[1]));
                    }
                }
            }

            return(new Tuple <string, IList <MethodParameter> >(methodName !, parameters));
        }
        /// <summary>
        /// This is responsible for invoking Execute on the Task
        /// Any method calling ExecuteTask must remember to call CleanupTask
        /// </summary>
        /// <remarks>
        /// We also allow the Task to have a reference to the BuildEngine by design
        /// at ITask.BuildEngine
        /// </remarks>
        /// <param name="oopTaskHostNode">The OutOfProcTaskHostNode as the BuildEngine</param>
        /// <param name="taskName">The name of the task to be executed</param>
        /// <param name="taskLocation">The path of the task binary</param>
        /// <param name="taskFile">The path to the project file in which the task invocation is located.</param>
        /// <param name="taskLine">The line in the project file where the task invocation is located.</param>
        /// <param name="taskColumn">The column in the project file where the task invocation is located.</param>
        /// <param name="appDomainSetup">The AppDomainSetup that we want to use to launch our AppDomainIsolated tasks</param>
        /// <param name="taskParams">Parameters that will be passed to the task when created</param>
        /// <returns>Task completion result showing success, failure or if there was a crash</returns>
        internal OutOfProcTaskHostTaskResult ExecuteTask
        (
            IBuildEngine oopTaskHostNode,
            string taskName,
            string taskLocation,
            string taskFile,
            int taskLine,
            int taskColumn,
#if FEATURE_APPDOMAIN
            AppDomainSetup appDomainSetup,
#endif
            IDictionary <string, TaskParameter> taskParams
        )
        {
            buildEngine   = oopTaskHostNode;
            this.taskName = taskName;

#if FEATURE_APPDOMAIN
            _taskAppDomain = null;
#endif
            wrappedTask = null;

            LoadedType taskType = null;
            try
            {
                TypeLoader typeLoader = new TypeLoader(TaskLoader.IsTaskClass);
                taskType = typeLoader.Load(taskName, AssemblyLoadInfo.Create(null, taskLocation));
            }
            catch (Exception e)
            {
                if (ExceptionHandling.IsCriticalException(e))
                {
                    throw;
                }

                Exception exceptionToReturn = e;

                // If it's a TargetInvocationException, we only care about the contents of the inner exception,
                // so just save that instead.
                if (e is TargetInvocationException)
                {
                    exceptionToReturn = e.InnerException;
                }

                return(new OutOfProcTaskHostTaskResult
                       (
                           TaskCompleteType.CrashedDuringInitialization,
                           exceptionToReturn,
                           "TaskInstantiationFailureError",
                           new string[] { taskName, taskLocation, String.Empty }
                       ));
            }

            OutOfProcTaskHostTaskResult taskResult;
            if (taskType.HasSTAThreadAttribute())
            {
#if FEATURE_APARTMENT_STATE
                taskResult = InstantiateAndExecuteTaskInSTAThread(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
#if FEATURE_APPDOMAIN
                                                                  appDomainSetup,
#endif
                                                                  taskParams);
#else
                return(new OutOfProcTaskHostTaskResult
                       (
                           TaskCompleteType.CrashedDuringInitialization,
                           null,
                           "TaskInstantiationFailureNotSupported",
                           new string[] { taskName, taskLocation, typeof(RunInSTAAttribute).FullName }
                       ));
#endif
            }
            else
            {
                taskResult = InstantiateAndExecuteTask(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
#if FEATURE_APPDOMAIN
                                                       appDomainSetup,
#endif
                                                       taskParams);
            }

            return(taskResult);
        }
示例#17
0
        /// <summary>
        /// Initialize the factory from the task registry
        /// </summary>
        internal LoadedType InitializeFactory
        (
            AssemblyLoadInfo loadInfo,
            string taskName,
            IDictionary <string, TaskPropertyInfo> taskParameters,
            string taskElementContents,
            IDictionary <string, string> taskFactoryIdentityParameters,
            bool taskHostFactoryExplicitlyRequested,
            TargetLoggingContext targetLoggingContext,
            ElementLocation elementLocation,
            string taskProjectFile
        )
        {
            ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo");
            VerifyThrowIdentityParametersValid(taskFactoryIdentityParameters, elementLocation, taskName, "Runtime", "Architecture");

            if (taskFactoryIdentityParameters != null)
            {
                _factoryIdentityParameters = new Dictionary <string, string>(taskFactoryIdentityParameters, StringComparer.OrdinalIgnoreCase);
            }

            _taskHostFactoryExplicitlyRequested = taskHostFactoryExplicitlyRequested;

            try
            {
                ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
                _taskName   = taskName;
                _loadedType = _typeLoader.Load(taskName, loadInfo);
                ProjectErrorUtilities.VerifyThrowInvalidProject(_loadedType != null, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, String.Empty);
            }
            catch (TargetInvocationException e)
            {
                // Exception thrown by the called code itself
                // Log the stack, so the task vendor can fix their code
                ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());
            }
            catch (ReflectionTypeLoadException e)
            {
                // ReflectionTypeLoadException.LoaderExceptions may contain nulls
                foreach (Exception exception in e.LoaderExceptions)
                {
                    if (exception != null)
                    {
                        targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, exception.Message);
                    }
                }

                ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
            }
            catch (ArgumentNullException e)
            {
                // taskName may be null
                ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
            }
            catch (Exception e) // Catching Exception, but rethrowing unless it's a well-known exception.
            {
                if (ExceptionHandling.NotExpectedReflectionException(e))
                {
                    throw;
                }

                ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
            }

            return(_loadedType);
        }