C# DataServiceContext.GetEntityDescriptor方法代码示例

        public static EntityStates GetStateForEntity(DataServiceContext context, object target)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            EntityDescriptor descriptor = context.GetEntityDescriptor(target);
            EntityStates result = (descriptor == null) ? EntityStates.Detached : descriptor.State;
            return result;
        }

        public void AdvertiseLargeNumberOfActionsTests()
        {
            // Test advertising large number of actions.
            var testCases = new[]
            {   
                new 
                {
                    RequestUri = "/Customers(1)",
                },
            };

            using (TestWebRequest request = service.CreateForInProcessWcf())
            {
                request.StartService();
                t.TestUtil.RunCombinations(testCases, (testCase) =>
                {
                    DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                    ctx.EnableAtom = true;
                    ctx.Format.UseAtom();
                    ctx.ResolveType = name => typeof(Customer);
                    Uri uri = new Uri(request.ServiceRoot + testCase.RequestUri);
                    QueryOperationResponse<object> qor = (QueryOperationResponse<object>)ctx.Execute<object>(uri);
                    Assert.IsNotNull(qor);
                    IEnumerator<object> entities = qor.GetEnumerator();
                    entities.MoveNext();
                    Assert.IsNotNull(entities.Current);
                    EntityDescriptor ed = ctx.GetEntityDescriptor(entities.Current);
                    Assert.IsNotNull(ed);
                    Assert.IsNotNull(ed.OperationDescriptors);
                    Assert.AreEqual(ed.OperationDescriptors.Count(), TotalNumberOfActions, "Invalid count of total number of advertised actions.");
                });
            }
        }

        private void RunPositiveFunctionTest(ODataFormat format, TestCase testCase)
        {
            // All of the functions tests use the PlaybackService since the WCF Data Services server doesn't support functions
            // The PlaybackService itself will not automatically turn Metadata into an absolute URI, so set that to false on all tests.
            // The tests also use absolute URIs for Target, so suppress that as well.
            testCase.AddBaseUriToMetadata = false;
            testCase.AddBaseUriToTarget = false;

            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            using (PlaybackService.ProcessRequestOverride.Restore())
            {
                request.ServiceType = typeof(AstoriaUnitTests.Stubs.PlaybackService);
                request.StartService();

                var payloadBuilder = testCase.ResponsePayloadBuilder;
                PlaybackService.ProcessRequestOverride.Value = (req) =>
                {
                    string contentType;
                    if (format == ODataFormat.Json)
                    {
                        contentType = UnitTestsUtil.JsonLightMimeType;
                        payloadBuilder.Metadata = request.BaseUri + "/$metadata#TestService.CustomerEntities/$entity";
                    }
                    else
                    {
                        contentType = UnitTestsUtil.AtomFormat;
                    }

                    req.SetResponseStreamAsText(PayloadGenerator.Generate(payloadBuilder, format));
                    req.ResponseHeaders.Add("Content-Type", contentType);
                    req.SetResponseStatusCode(200);
                    return req;
                };

                testCase.AddBaseUriStringToExpectedDescriptors(request.ServiceRoot.OriginalString, format);

                Uri uri = new Uri(request.ServiceRoot + "/" + testCase.RequestUriString);
                DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                ctx.EnableAtom = true;

                if (format == ODataFormat.Json)
                {
                    string serviceEdmx = GetServiceEdmxWithOperations(payloadBuilder);
                    JsonLightTestUtil.ConfigureContextForJsonLight(ctx, serviceEdmx);
                }

                QueryOperationResponse<CustomerEntity> qor = (QueryOperationResponse<CustomerEntity>)ctx.Execute<CustomerEntity>(uri);
                Assert.IsNotNull(qor);
                Assert.IsNull(qor.Error);

                IEnumerator<CustomerEntity> entities = qor.GetEnumerator();

                int expectedDescriptorsPerEntity = 0;

                while (entities.MoveNext())
                {
                    CustomerEntity c = entities.Current;
                    EntityDescriptor ed = ctx.GetEntityDescriptor(c);
                    IEnumerable<OperationDescriptor> actualDescriptors = ed.OperationDescriptors;
                    TestEquality(actualDescriptors, testCase.GetExpectedDescriptors(format)[expectedDescriptorsPerEntity++]);
                }
            }
        }

        private static void RunPositiveTest(ODataFormat format, TestCase testCase)
        {
            MyDSPActionProvider actionProvider = new MyDSPActionProvider();
            DSPServiceDefinition service = new DSPServiceDefinition() {Metadata = Metadata, CreateDataSource = CreateDataSource, ActionProvider = actionProvider};
            service.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;

            using (TestWebRequest request = service.CreateForInProcessWcf())
            {
                request.StartService();
                DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                ctx.EnableAtom = true;

                Uri uri = new Uri(request.ServiceRoot + "/" + testCase.RequestUriString);

                MakeFinalChangesToTestCase(testCase, format, actionProvider, request);

                if (format == ODataFormat.Json)
                {
                    JsonLightTestUtil.ConfigureContextForJsonLight(ctx, null);
                }
                else
                {
                    ctx.Format.UseAtom();
                }

                QueryOperationResponse<CustomerEntity> qor = (QueryOperationResponse<CustomerEntity>)ctx.Execute<CustomerEntity>(uri);
                Assert.IsNotNull(qor);
                Assert.IsNull(qor.Error);

                IEnumerator<CustomerEntity> entities = qor.GetEnumerator();

                int expectedDescriptorsPerEntity = 0;

                while (entities.MoveNext())
                {
                    CustomerEntity c = entities.Current;
                    EntityDescriptor ed = ctx.GetEntityDescriptor(c);
                    IEnumerable<OperationDescriptor> actualDescriptors = ed.OperationDescriptors;
                    TestEquality(actualDescriptors, testCase.GetExpectedDescriptors(format)[expectedDescriptorsPerEntity++]);
                }
            }
        }

        private static void RunNegativeActionTestWithAtom(TestCase testCase)
        {
            // These tests are specific to Atom and don't apply to JSON Light.
            // Any JSON Light negative cases are covered by ODL reader tests. See ODL tests OperationReaderJsonLightTests and ODataJsonLightDeserializerTests.
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            using (PlaybackService.ProcessRequestOverride.Restore())
            {
                request.ServiceType = typeof(AstoriaUnitTests.Stubs.PlaybackService);
                request.StartService();
                
                PlaybackService.ProcessRequestOverride.Value = (req) =>
                {
                    // These tests intentionally don't set the base URI of the context, so we need to also remove the xml:base attribute that is automatically
                    // generated by the PayloadGenerator. Otherwise another parsing error will occur before we hit the actual errors we are trying to validate.
                    string payload = PayloadGenerator.Generate(testCase.ResponsePayloadBuilder, ODataFormat.Atom);
                    string xmlBaseAttribute = @"xml:base=""/""";
                    payload = payload.Remove(payload.IndexOf(xmlBaseAttribute), xmlBaseAttribute.Length);

                    req.SetResponseStreamAsText(payload);
                    req.ResponseHeaders.Add("Content-Type", "application/atom+xml");
                    req.SetResponseStatusCode(200);
                    return req;
                };

                Uri uri = new Uri(request.ServiceRoot + "/" + testCase.RequestUriString);
                DataServiceContext ctx = new DataServiceContext(null, ODataProtocolVersion.V4);
                ctx.EnableAtom = true;

                QueryOperationResponse<CustomerEntity> qor = (QueryOperationResponse<CustomerEntity>)ctx.Execute<CustomerEntity>(uri);
                Assert.IsNotNull(qor);
                Assert.IsNull(qor.Error);

                IEnumerator<CustomerEntity> entities = qor.GetEnumerator();

                Exception exception = AstoriaTest.TestUtil.RunCatching(delegate()
                {
                    while (entities.MoveNext())
                    {
                        CustomerEntity c = entities.Current;
                        EntityDescriptor ed = ctx.GetEntityDescriptor(c);
                        IEnumerable<OperationDescriptor> actualDescriptors = ed.OperationDescriptors;
                    }
                });

                Assert.IsNotNull(exception);
                Assert.AreEqual(testCase.ExpectedErrorMessage, exception.Message);
            }    
        }

        public void NamedStreams_SimpleLinkProjection()
        {
            // Simple projections to get stream url in DSSL property - both narrow type and anonymous type
            {
                // Testing querying anonymous types and making sure one is able to project out the stream url
                DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                context.EnableAtom = true;
                context.Format.UseAtom();
                var q = from s in context.CreateQuery<EntityWithNamedStreams1>("MySet1")
                        select new
                        {
                            ID = s.ID,
                            Stream11 = s.Stream1
                        };

                Assert.AreEqual(q.ToString(), request.ServiceRoot.AbsoluteUri + "/MySet1?$select=ID,Stream1", "make sure the right uri is produced by the linq translator");
                foreach (var o in q)
                {
                    Assert.IsNotNull(o.Stream11, "Stream11 must have some value");
                    Assert.AreEqual(o.Stream11.EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet1(1)/Stream1", "make sure the url property is correctly populated");
                    Assert.IsNull(context.GetEntityDescriptor(o), "anonymous types are never tracked, even if we do a simple projection");
                }

                Assert.AreEqual(context.Entities.Count, 0, "there should be no entity tracked by the context");
            }

            {
                // Testing querying narrow entity types and making sure one is able to project out the stream url
                DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                context.EnableAtom = true;
                context.Format.UseAtom();
                var q = from s in context.CreateQuery<EntityWithNamedStreams1>("MySet1")
                        select new EntityWithNamedStreams1
                        {
                            ID = s.ID,
                            Stream1 = s.Stream1
                        };

                Assert.AreEqual(q.ToString(), request.ServiceRoot.AbsoluteUri + "/MySet1?$select=ID,Stream1", "make sure the right uri is produced by the linq translator");
                foreach (EntityWithNamedStreams1 o in q)
                {
                    Assert.IsNotNull(o.Stream1, "Stream11 must have some value");
                    Assert.AreEqual(o.Stream1.EditLink, context.GetReadStreamUri(o, "Stream1"), "the value in the entity descriptor must match with the property value");
                }

                Assert.AreEqual(context.Entities.Count, 1, "there should be only one entity tracked by the context");
            }
        }

        public void NamedStreams_DeepLinkProjection()
        {
            // projecting out deep links to get stream url in DSSL property - both narrow type and anonymous type
            {
                // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property
                DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                context.EnableAtom = true;
                context.Format.UseAtom();
                var q = from s in context.CreateQuery<EntityWithNamedStreams1>("MySet1")
                        select new
                        {
                            ID = s.Ref.ID,
                            Url = s.Ref.RefStream1
                        };

                Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Ref($select=ID),Ref($select=RefStream1)", q.ToString(), "make sure the right uri is produced by the linq translator");

                foreach (var o in q)
                {
                    Assert.IsNotNull(o.Url, "Stream11 must have some value");
                    Assert.AreEqual(o.Url.EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet2(3)/RefStream1", "the stream url must be populated correctly");
                    Assert.IsNull(context.GetEntityDescriptor(o), "the entity must not be tracked by the context since we are trying to flatten the hierarchy");
                }

                Assert.AreEqual(context.Entities.Count, 0, "there should be no entities tracked by the context, since we are doing flattening");
            }

            {
                // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property
                DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
                context.EnableAtom = true;
                context.Format.UseAtom();
                var q = from s in context.CreateQuery<EntityWithNamedStreams1>("MySet1")
                        select new EntityWithNamedStreams1
                        {
                            ID = s.Ref.ID,
                            RefStream1 = s.Ref.RefStream1
                        };

                Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Ref($select=ID),Ref($select=RefStream1)", q.ToString(), "make sure the right uri is produced by the linq translator");

                foreach (var o in q)
                {
                    Assert.IsNotNull(o.RefStream1, "Stream11 must have some value");
                    Assert.AreEqual(o.RefStream1.EditLink, context.GetReadStreamUri(o, "RefStream1"), "the stream url must be populated correctly");
                }

                Assert.AreEqual(context.Entities.Count, 1, "there should be exactly one entity tracked by the context - the nested entity");
                Assert.AreEqual(context.Entities[0].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet2(3)", "the nested entity is the one that should be tracked");
            }
        }

            private static void VerifyStateOfEntities(DataServiceContext ctx, IEnumerable<object> entities, EntityStates expectedState)
            {
                Debug.Assert(ctx != null, "ctx != null");
                Debug.Assert(entities != null, "entities != null");

                foreach (object entity in entities)
                {
                    EntityDescriptor descriptor = ctx.GetEntityDescriptor(entity);
                    Debug.Assert(descriptor != null, "EntityDescriptor not found for the given entity");
                    Assert.AreEqual(expectedState, descriptor.State);
                }
            }