public void ClientCodeGenerationDispatcher_Finds_Derived_Custom() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "G#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, MockGSharpCodeGeneratorDerived.GeneratorName); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.AreEqual(generator.GetType(), typeof(MockGSharpCodeGeneratorDerived), "dispatcher found " + generator.GetType() + " but should have found MockGSharpCodeGeneratorDerived"); string generatedCode = generator.GenerateCode(host, Enumerable.Empty <DomainServiceDescription>(), options); Assert.AreEqual(MockGSharpCodeGeneratorDerived.DerivedGeneratedCode, generatedCode, "test code generator did not generate expected code."); } }
// Invokes the code generator discovered via the host and options internal static string GenerateCode(ICodeGenerationHost host, ClientCodeGenerationOptions options, IEnumerable <Type> domainServiceTypes) { IDomainServiceClientCodeGenerator generator = CreateCodeGenerator(host, options); DomainServiceCatalog catalog = new DomainServiceCatalog(domainServiceTypes, host as ILogger); return(generator.GenerateCode(host, catalog.DomainServiceDescriptions, options)); }
public void ClientCodeGenerationDispatcher_Custom_Warns_Full() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, MockCodeGenerator.GeneratorName); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.AreEqual(generator.GetType(), typeof(MockCodeGenerator), "dispatcher found " + generator.GetType() + " but should have found MockCodeGenerator"); // Setting this option makes our custom code generator emit the packet below to test LogWarning MockCodeGenerator.LogWarningsFull = true; string generatedCode = generator.GenerateCode(host, Enumerable.Empty <DomainServiceDescription>(), options); Assert.AreEqual(MockCodeGenerator.FakeGeneratedCode, generatedCode, "test code generator did not generate expected code."); TestHelper.AssertContainsWarningPackets(logger, MockCodeGenerator.WarningPacket); } }
public void ClientCodeGenerationDispatcher_Custom_By_AssemblyQualifiedName() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[0]; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, typeof(T4DomainServiceClientCodeGenerator).AssemblyQualifiedName); Assert.IsNotNull(generator, "the dispatcher did not find the code generator"); Assert.AreEqual(generator.GetType(), typeof(T4DomainServiceClientCodeGenerator), "dispatcher found " + generator.GetType() + " but should have found T4DomainServiceClientProxyGenerator"); string generatedCode = generator.GenerateCode(host, Enumerable.Empty <DomainServiceDescription>(), options); Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "expected T4 generator to generate code"); TestHelper.AssertGeneratedCodeContains(generatedCode, T4DomainServiceClientCodeGenerator.GeneratedBoilerPlate); TestHelper.AssertNoErrorsOrWarnings(logger); } }
public void ClientCodeGenerationDispatcher_Error_Multiple_Generators() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#", ClientProjectPath = "ClientProject" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location, typeof(T4DomainServiceClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, /*generatorName*/ null); Assert.IsNotNull(generator, "the dispatcher did not pick a generator"); Assert.IsTrue(generator is CodeDomClientCodeGenerator, "the dispatcher did not pick the default code generator"); string errorParam = " " + MockCodeGenerator.GeneratorName + Environment.NewLine + " " + T4DomainServiceClientCodeGenerator.GeneratorName + Environment.NewLine; string error = (string.Format(CultureInfo.CurrentCulture, Resource.Multiple_Custom_Code_Generators_Using_Default, options.Language, errorParam, options.ClientProjectPath, MockCodeGenerator.GeneratorName, CodeDomClientCodeGenerator.GeneratorName)); TestHelper.AssertContainsWarnings(logger, error); } }
public void ClientCodeGenerationDispatcher_Generate_Using_T4_Custom() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { typeof(T4DomainServiceClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, null); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.AreEqual(generator.GetType(), typeof(T4DomainServiceClientCodeGenerator), "dispatcher found " + generator.GetType() + " but should have found T4DomainServiceClientProxyGenerator"); DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(DispatcherDomainService)); string generatedCode = generator.GenerateCode(host, new DomainServiceDescription[] { dsd }, options); Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "expected T4 generator to generate code"); TestHelper.AssertGeneratedCodeContains(generatedCode, T4DomainServiceClientCodeGenerator.GeneratedBoilerPlate); TestHelper.AssertGeneratedCodeContains(generatedCode, "public class DispatcherEntity : Entity"); TestHelper.AssertNoErrorsOrWarnings(logger); } }
public void ClientCodeGenerationDispatcher_Finds_Default_By_Name() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location, typeof(T4DomainServiceClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, CodeDomClientCodeGenerator.GeneratorName); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.IsTrue(typeof(CodeDomClientCodeGenerator).IsAssignableFrom(generator.GetType()), "dispatcher found " + generator.GetType() + " but should have found CodeDomClientCodeGenerator"); DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(DispatcherDomainService)); string generatedCode = generator.GenerateCode(host, new DomainServiceDescription[] { dsd }, options); Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "expected code to have been generated"); Assert.IsTrue(generatedCode.Contains("public sealed partial class DispatcherDomainContext : DomainContext"), "Expected generated code to contain public sealed partial class DispatcherDomainContext : DomainContext"); } }
public void ClientCodeGenerationDispatcher_Finds_Solitary_Custom() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location, typeof(TextTemplate::OpenRiaServices.DomainServices.Tools.TextTemplate.ClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, /*generatorName*/ null); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.AreEqual(generator.GetType(), typeof(MockCodeGenerator), "dispatcher found " + generator.GetType() + " but should have found MockCodeGenerator"); string generatedCode = generator.GenerateCode(host, Enumerable.Empty <DomainServiceDescription>(), options); Assert.AreEqual(MockCodeGenerator.FakeGeneratedCode, generatedCode, "test code generator did not generate expected code."); // Expect informational message string message = string.Format(CultureInfo.CurrentCulture, Resource.Using_Custom_Code_Generator, MockCodeGenerator.GeneratorName); TestHelper.AssertContainsMessages(logger, message); } }
public void ClientCodeGenerationDispatcher_Error_Missing_Custom() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#", ClientProjectPath = "ClientProject", ServerProjectPath = "ServerProject" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, "NotAGenerator"); Assert.IsNull(generator, "the dispatcher should not find any code generator"); string error = string.Format(CultureInfo.CurrentCulture, Resource.Code_Generator_Not_Found, "NotAGenerator", options.Language, options.ServerProjectPath, options.ClientProjectPath, CodeDomClientCodeGenerator.GeneratorName); TestHelper.AssertContainsErrors(logger, error); } }
// Locates the code generator registered to work with the language for the given options internal static IDomainServiceClientCodeGenerator CreateCodeGenerator(ICodeGenerationHost host, ClientCodeGenerationOptions options) { using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, /*compositionAssemblies*/ null, /*codeGeneratorName*/ null); return(generator); } }
public void ClientCodeGenerationDispatcher_Error_TypeLoadException() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#", }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { // We want to include into the MEF container an assembly that will throw TypeLoadException // when MEF tries to analyze it. This is to test our own recovery, which should consist // of logging an error making a default container containing only Tools. string unitTestAssemblyLocation = Assembly.GetExecutingAssembly().Location; string typeLoadExceptionProjectLocation = Path.Combine(Path.GetDirectoryName(unitTestAssemblyLocation), "TypeLoadExceptionProject.dll"); Assert.IsTrue(File.Exists(typeLoadExceptionProjectLocation), "Expected TypeLoadExceptionProject.dll to coreside with this assembly in test folder"); // Do what MEF does to load the types so we can capture the exception Exception expectedException = null; try { Assembly assembly = Assembly.LoadFrom(typeLoadExceptionProjectLocation); assembly.GetTypes(); } catch (Exception ex) { expectedException = ex; } Assert.IsNotNull(expectedException, "We did not generate the type load exception we expected"); string[] compositionAssemblies = new string[] { unitTestAssemblyLocation, typeLoadExceptionProjectLocation }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, /*generatorName*/ null); Assert.IsNotNull(generator, "the dispatcher did not pick default generator"); Assert.IsTrue(generator is CodeDomClientCodeGenerator, "the dispatcher did not pick the default code generator"); string error = (string.Format(CultureInfo.CurrentCulture, Resource.Failed_To_Create_Composition_Container, expectedException.Message)); TestHelper.AssertContainsWarnings(logger, error); } }
/// <summary> /// Generates client proxy source code using the specified <paramref name="codeGeneratorName"/> in the context /// of the specified <paramref name="host"/>. /// </summary> /// <param name="host">The host for code generation.</param> /// <param name="options">The options to use for code generation.</param> /// <param name="catalog">The catalog containing the <see cref="OpenRiaServices.DomainServices.Server.DomainService"/> types.</param> /// <param name="compositionAssemblies">The optional set of assemblies to use to create the MEF composition container.</param> /// <param name="codeGeneratorName">Optional generator name. A <c>null</c> or empty value will select the default generator.</param> /// <returns>The generated source code or <c>null</c> if none was generated.</returns> private string GenerateCode(ICodeGenerationHost host, ClientCodeGenerationOptions options, DomainServiceCatalog catalog, IEnumerable <string> compositionAssemblies, string codeGeneratorName) { Debug.Assert(host != null, "host cannot be null"); Debug.Assert(options != null, "options cannot be null"); Debug.Assert(catalog != null, "catalog cannot be null"); IEnumerable <DomainServiceDescription> domainServiceDescriptions = catalog.DomainServiceDescriptions; IDomainServiceClientCodeGenerator proxyGenerator = this.FindCodeGenerator(host, options, compositionAssemblies, codeGeneratorName); string generatedCode = null; if (proxyGenerator != null) { try { generatedCode = proxyGenerator.GenerateCode(host, domainServiceDescriptions, options); } catch (Exception ex) { // Fatal exceptions are never swallowed or processed if (ex.IsFatal()) { throw; } // Any exception from the code generator is caught and reported, otherwise it will // hit the MSBuild backstop and report failure of the custom build task. // It is acceptable to report this exception and "ignore" it because we // are running in a separate AppDomain which will be torn down immediately // after our return. host.LogError(string.Format(CultureInfo.CurrentCulture, Resource.CodeGenerator_Threw_Exception, string.IsNullOrEmpty(codeGeneratorName) ? proxyGenerator.GetType().FullName : codeGeneratorName, options.ClientProjectPath, ex.Message)); } } return(generatedCode); }
public void ClientCodeGenerationDispatcher_Custom_By_AssemblyQualifiedName_Ctor_Throws() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); string codeGeneratorName = typeof(ThrowingCtorCodeGenerator).AssemblyQualifiedName; // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[0]; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, codeGeneratorName); Assert.IsNull(generator, "the dispatcher should not find the code generator"); string error = string.Format(CultureInfo.CurrentCulture, Resource.Code_Generator_Instantiation_Error, codeGeneratorName, ThrowingCtorCodeGenerator.ErrorMessage); TestHelper.AssertContainsErrors(logger, error); } }
public void ClientCodeGenerationDispatcher_Error_Multiple_Generators_Same_Name() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "F#", ClientProjectPath = "ClientProject", ServerProjectPath = "ServerProject" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location }; string generatorName = MockFSharpCodeGenerator1.GeneratorName; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, generatorName); Assert.IsNull(generator, "the dispatcher should not pick a generator"); string errorParam = " " + typeof(MockFSharpCodeGenerator1).FullName + Environment.NewLine + " " + typeof(MockFSharpCodeGenerator2).FullName + Environment.NewLine; string error = string.Format(CultureInfo.CurrentCulture, Resource.Multiple_Named_Code_Generators, generatorName, options.Language, errorParam, options.ServerProjectPath, options.ClientProjectPath, typeof(MockFSharpCodeGenerator1).AssemblyQualifiedName); TestHelper.AssertContainsErrors(logger, error); } }
/// <summary> /// Locates and returns the <see cref="IDomainServiceClientCodeGenerator"/> to use to generate client proxies /// for the specified <paramref name="options"/>. /// </summary> /// <param name="host">The host for code generation.</param> /// <param name="options">The options to use for code generation.</param> /// <param name="compositionAssemblies">The optional set of assemblies to use to create the MEF composition container.</param> /// <param name="codeGeneratorName">Optional generator name. A <c>null</c> or empty value will select the default generator.</param> /// <returns>The code generator to use, or <c>null</c> if a matching one could not be found.</returns> internal IDomainServiceClientCodeGenerator FindCodeGenerator(ICodeGenerationHost host, ClientCodeGenerationOptions options, IEnumerable <string> compositionAssemblies, string codeGeneratorName) { Debug.Assert(host != null, "host cannot be null"); Debug.Assert(options != null, "options cannot be null"); if (string.IsNullOrEmpty(options.Language)) { throw new ArgumentException(Resource.Null_Language_Property, nameof(options)); } IDomainServiceClientCodeGenerator generator = null; // Try to load the code generator directly if given an assembly qualified name. // We insist on at least one comma in the name to know this is an assembly qualified name. // Otherwise, we might succeed in loading a dotted name that happens to be in our assembly, // such as the default CodeDom generator. if (!string.IsNullOrEmpty(codeGeneratorName) && codeGeneratorName.Contains(',')) { Type codeGeneratorType = Type.GetType(codeGeneratorName, /*throwOnError*/ false); if (codeGeneratorType != null) { if (!typeof(IDomainServiceClientCodeGenerator).IsAssignableFrom(codeGeneratorType)) { // If generator is of the incorrect type, we will still allow the MEF approach below // to find a better one. This path could be exercised by inadvertantly using a name // that happened to load some random type that was not a code generator. host.LogWarning(string.Format(CultureInfo.CurrentCulture, Resource.Code_Generator_Incorrect_Type, codeGeneratorName)); } else { try { generator = Activator.CreateInstance(codeGeneratorType) as IDomainServiceClientCodeGenerator; } catch (Exception e) { // The open catch of Exception is acceptable because we unconditionally report // the error and are running in a separate AppDomain. if (e.IsFatal()) { throw; } host.LogError(string.Format(CultureInfo.CurrentCulture, Resource.Code_Generator_Instantiation_Error, codeGeneratorName, e.Message)); } } } } if (generator == null) { // Create the MEF composition container (once only) from the assemblies we are analyzing this.CreateCompositionContainer(compositionAssemblies, host as ILogger); // The following property is filled by MEF by the line above. if (this.DomainServiceClientCodeGenerators != null && this.DomainServiceClientCodeGenerators.Any()) { // Select only those registered for the required language IEnumerable <Lazy <IDomainServiceClientCodeGenerator, ICodeGeneratorMetadata> > allImportsForLanguage = this.DomainServiceClientCodeGenerators.Where(i => string.Equals(options.Language, i.Metadata.Language, StringComparison.OrdinalIgnoreCase)); Lazy <IDomainServiceClientCodeGenerator, ICodeGeneratorMetadata> lazyImport = null; // If client specified a specific generator, use that one. // If it cannot be found, log an error to explain the problem. // If multiple with that name are found, log an error and explain the problem. // We consider this an error because the user has explicitly named a generator, // meaning they would not expect the default to be used. if (!string.IsNullOrEmpty(codeGeneratorName)) { IEnumerable <Lazy <IDomainServiceClientCodeGenerator, ICodeGeneratorMetadata> > allImportsForLanguageAndName = allImportsForLanguage.Where(i => string.Equals(i.Metadata.GeneratorName, codeGeneratorName, StringComparison.OrdinalIgnoreCase)); int numberOfMatchingGenerators = allImportsForLanguageAndName.Count(); // No generator with that name was found. Log an error and explain how to register one. if (numberOfMatchingGenerators == 0) { host.LogError(string.Format(CultureInfo.CurrentCulture, Resource.Code_Generator_Not_Found, codeGeneratorName, options.Language, options.ServerProjectPath, options.ClientProjectPath, CodeDomClientCodeGenerator.GeneratorName)); } else if (numberOfMatchingGenerators == 1) { // Exactly one was found -- take it lazyImport = allImportsForLanguageAndName.First(); } else { // Multiple with that name were found. Explain how to remove some of them or // explicitly name one. StringBuilder sb = new StringBuilder(); foreach (var import in allImportsForLanguageAndName.OrderBy(i => i.Value.GetType().FullName)) { sb.AppendLine(" " + import.Value.GetType().FullName); } host.LogError(string.Format(CultureInfo.CurrentCulture, Resource.Multiple_Named_Code_Generators, codeGeneratorName, options.Language, sb.ToString(), options.ServerProjectPath, options.ClientProjectPath, allImportsForLanguageAndName.First().Value.GetType().AssemblyQualifiedName)); } } else { // We are here if no generator name was specified. // If only one import matched the language, we have it. // This is the most common path to discovery of our own CodeDom generator // but will work equally well when it replaced. if (allImportsForLanguage.Count() == 1) { lazyImport = allImportsForLanguage.First(); } else { // Multiple custom generators exist, but a specific generator name was not provided. // Look for any custom generators other than our default CodeDom one. // If we find there is only one custom generator registered, we use that one rather than the default IEnumerable <Lazy <IDomainServiceClientCodeGenerator, ICodeGeneratorMetadata> > customGeneratorImports = allImportsForLanguage.Where(i => !string.Equals(CodeDomClientCodeGenerator.GeneratorName, i.Metadata.GeneratorName, StringComparison.OrdinalIgnoreCase)); int generatorCount = customGeneratorImports.Count(); // Exactly 1 custom generator that is not the default -- take it if (generatorCount == 1) { lazyImport = customGeneratorImports.First(); host.LogMessage(string.Format(CultureInfo.CurrentCulture, Resource.Using_Custom_Code_Generator, lazyImport.Metadata.GeneratorName)); } else if (generatorCount != 0) { // Multiple generators are available but we have insufficient information // to choose one. Log an warning and use the default StringBuilder sb = new StringBuilder(); // Sort for unit test predictability IEnumerable <Lazy <IDomainServiceClientCodeGenerator, ICodeGeneratorMetadata> > orderedCustomGenerators = customGeneratorImports.OrderBy(i => i.Metadata.GeneratorName); foreach (var import in orderedCustomGenerators) { sb.AppendLine(" " + import.Metadata.GeneratorName); } host.LogWarning(string.Format(CultureInfo.CurrentCulture, Resource.Multiple_Custom_Code_Generators_Using_Default, options.Language, sb.ToString(), options.ClientProjectPath, orderedCustomGenerators.First().Metadata.GeneratorName, CodeDomClientCodeGenerator.GeneratorName)); // Pick the default. There should be one, but if not, the calling methods will detect and report a problem. lazyImport = allImportsForLanguage.FirstOrDefault(i => string.Equals(CodeDomClientCodeGenerator.GeneratorName, i.Metadata.GeneratorName, StringComparison.OrdinalIgnoreCase)); } } } generator = lazyImport == null ? null : lazyImport.Value; } } return(generator); }