public void PropertyGetAndSet() { DomainIdentifierAttribute dia = null; // Name dia = new DomainIdentifierAttribute(null); ExceptionHelper.ExpectException <InvalidOperationException>( () => Assert.IsNull(dia.Name, "This should fail.")); string name = "name"; dia = new DomainIdentifierAttribute(name); Assert.AreEqual(name, dia.Name, "Names should be equal."); // IsApplicationService Assert.IsFalse(dia.IsApplicationService, "IsApplicationService state should be false by default."); bool isApplicationService = true; dia.IsApplicationService = isApplicationService; Assert.AreEqual(isApplicationService, dia.IsApplicationService, "IsApplicationService states should be equal."); }
public void PropertyGetAndSet() { DomainIdentifierAttribute dia = null; // Name dia = new DomainIdentifierAttribute(null); ExceptionHelper.ExpectException<InvalidOperationException>( () => Assert.IsNull(dia.Name, "This should fail.")); string name = "name"; dia = new DomainIdentifierAttribute(name); Assert.AreEqual(name, dia.Name, "Names should be equal."); // IsApplicationService Assert.IsFalse(dia.IsApplicationService, "IsApplicationService state should be false by default."); bool isApplicationService = true; dia.IsApplicationService = isApplicationService; Assert.AreEqual(isApplicationService, dia.IsApplicationService, "IsApplicationService states should be equal."); }
public void DomainIdentifier_Name_Property_Settable() { DomainIdentifierAttribute attr = new DomainIdentifierAttribute("aName"); Assert.AreEqual("aName", attr.Name); attr.Name = "otherName"; Assert.AreEqual("otherName", attr.Name); }
public void DomainIdentifier_Ctor() { DomainIdentifierAttribute attr = new DomainIdentifierAttribute("aName"); Assert.AreEqual("aName", attr.Name); #if !SILVERLIGHT Assert.IsNull(attr.CodeProcessor); #endif }
public void DomainIdentifier_CodeProcessor_Property_Settable() { Type type1 = typeof(string); Type type2 = typeof(int); DomainIdentifierAttribute attr = new DomainIdentifierAttribute("aName"); attr.CodeProcessor = type1; Assert.AreEqual<Type>(type1, attr.CodeProcessor); attr.CodeProcessor = type2; Assert.AreEqual<Type>(type2, attr.CodeProcessor); }
public void DomainIdentifier_CodeProcessor_Property_Settable() { Type type1 = typeof(string); Type type2 = typeof(int); DomainIdentifierAttribute attr = new DomainIdentifierAttribute("aName"); attr.CodeProcessor = type1; Assert.AreEqual <Type>(type1, attr.CodeProcessor); attr.CodeProcessor = type2; Assert.AreEqual <Type>(type2, attr.CodeProcessor); }
private string GenerateProxyClass() { string generatedCode = string.Empty; // Analyze the assemblies to extract all the DomainServiceDescriptions ICollection <DomainServiceDescription> allDescriptions = this._domainServiceDescriptions; List <Type> generatedEntityTypes = new List <Type>(); List <Type> generatedComplexTypes = new List <Type>(); Dictionary <Type, CodeTypeDeclaration> typeMapping = new Dictionary <Type, CodeTypeDeclaration>(); // Used to queue CodeProcessor invocations Queue <CodeProcessorWorkItem> codeProcessorQueue = new Queue <CodeProcessorWorkItem>(); // Before we begin codegen, we want to register type names with our codegen // utilities so that we can avoid type name conflicts later. this.PreprocessProxyTypes(); // Generate a new domain service proxy class for each domain service we found. // OrderBy type name of DomainService to give code-gen predictability foreach (DomainServiceDescription dsd in allDescriptions.OrderBy(d => d.DomainServiceType.Name)) { // If we detect the client already has the DomainContext we would have // generated, skip it. This condition arises when the client has references // to class libraries as well as a code-gen link to the server which has // references to the server-side equivalent libraries. Without this check, we would // re-generate the same DomainContext that already lives in the class library. CodeMemberShareKind domainContextShareKind = this.GetDomainContextTypeMemberShareKind(dsd); if ((domainContextShareKind & CodeMemberShareKind.Shared) != 0) { this.LogMessage(string.Format(CultureInfo.CurrentCulture, Resource.Shared_DomainContext_Skipped, dsd.DomainServiceType.Name)); continue; } // Log information level message to help users see progress and debug code-gen issues this.LogMessage(string.Format(CultureInfo.CurrentCulture, Resource.CodeGen_Generating_DomainService, dsd.DomainServiceType.FullName)); new DomainServiceProxyGenerator(this, dsd, typeMapping).Generate(); // Generate all entities. this.GenerateDataContractTypes(dsd.EntityTypes, generatedEntityTypes, Resource.ClientCodeGen_EntityTypesCannotBeShared_Reference, t => { new EntityProxyGenerator(this, t, allDescriptions, typeMapping).Generate(); }); // Generate all complex types. this.GenerateDataContractTypes(dsd.ComplexTypes, generatedComplexTypes, Resource.ClientCodeGen_ComplexTypesCannotBeShared_Reference, t => { new ComplexTypeProxyGenerator(this, t, dsd, typeMapping).Generate(); }); DomainIdentifierAttribute domainIdentifier = dsd.Attributes.OfType <DomainIdentifierAttribute>().SingleOrDefault(); if (domainIdentifier != null) { Type codeProcessorType = domainIdentifier.CodeProcessor; if (codeProcessorType != null) { // Create a limited type-mapping dictionary that contains references to // the DomainService and related entity type CodeTypeDeclarations. Dictionary <Type, CodeTypeDeclaration> scopedTypeMapping = typeMapping.Where(kvp => kvp.Key == dsd.DomainServiceType || dsd.EntityTypes.Contains(kvp.Key)) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); // Register CodeProc codeProcessorQueue.Enqueue( new CodeProcessorWorkItem(codeProcessorType, dsd, scopedTypeMapping)); } } } // Generate an application-level WebContext class if (this.ClientProxyCodeGenerationOptions.IsApplicationContextGenerationEnabled) { new WebContextGenerator(this).Generate(); } // If there are no descriptions, we do not generate any client proxies // We don't consider this an error, since this task might be invoked before the user has created any. else if (allDescriptions.Count == 0) { return(generatedCode); } // Generate any enum types we have decided we need to generate this.GenerateAllEnumTypes(); // Fix up CodeDOM graph before invoking CodeProcessors this.FixUpCompileUnit(this.CompileUnit); // Invoke CodeProcessors after we've completed our CodeDOM graph while (codeProcessorQueue.Count > 0) { // Allow CodeProcessors to do post processing work CodeProcessorWorkItem workItem = codeProcessorQueue.Dequeue(); this.InvokeDomainServiceCodeProcessor(workItem); } // Write the entire "file" to a single string to permit us to redirect it // to a file, a TextBuffer, etc if (!this.CodeGenerationHost.HasLoggedErrors) { using (TextWriter t = new StringWriter(CultureInfo.InvariantCulture)) { this.Provider.GenerateCodeFromCompileUnit(this.CompileUnit, t, this._options); generatedCode = this.FixupVBOptionStatements(t.ToString()); } } return(generatedCode); }
public void Attributes_Cities_Entity_Has_DomainIdentifier() { DomainIdentifierAttribute attr = ExpectTypeAttribute <DomainIdentifierAttribute>(typeof(Zip)); Assert.AreEqual("ZipPattern", attr.Name); }
public void Attributes_Cities_DomainService_Has_DomainIdentifier() { DomainIdentifierAttribute attr = ExpectTypeAttribute <DomainIdentifierAttribute>(typeof(CityDomainContext)); Assert.AreEqual("CityProvider", attr.Name); }