{"id":1153,"date":"2010-09-08T18:19:23","date_gmt":"2010-09-08T18:19:23","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/odatateam\/2010\/09\/08\/data-services-streaming-provider-series-part-2-accessing-a-media-resource-stream-from-the-client\/"},"modified":"2024-02-16T13:30:39","modified_gmt":"2024-02-16T20:30:39","slug":"data-services-streaming-provider-series-part-2-accessing-a-media-resource-stream-from-the-client","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/odata\/data-services-streaming-provider-series-part-2-accessing-a-media-resource-stream-from-the-client\/","title":{"rendered":"Data Services Streaming Provider Series-Part 2: Accessing a Media Resource Stream from the Client"},"content":{"rendered":"

In this second post in the series on implementing a streaming data provider, we show how to use the WCF Data Services client library to access binary data exposed by an Open Data Protocol (OData) feed, as well as has how to upload binary data to the data service. For more information on the streaming provider, see the first blog post in this series: Implementing a Streaming Provider<\/a><\/font>.<\/p>\n

PhotoData Sample Client Application<\/h3>\n

In the previous post<\/a>, we showed how to implement IDataServiceStreamProvider<\/a> to create a data service that uses OData to store and retrieve binary image files, the media resource<\/em> (MR) in OData terms, along with metadata about the photos, the media link entry<\/em> (MLE) in OData terms. The Visual Studio solution for this sample data service, which is published to this MSDN Code Gallery page<\/a>, also contains a client application project. This client, which consumes feeds from the PhotoData service, accesses and displays image files stored by the data service. Creating a client application that can display photos from and send photos to our PhotoData sample data service requires the following basic steps:<\/p>\n

    \n
  1. Create the client project and add a reference to the data service. <\/li>\n
  2. Create the UI elements to display the MLE and MR data for the photo. <\/li>\n
  3. Request a data feed from the service, get the URI of the MR for a specific MLE, and then use this URI to create an image based on the MR. <\/li>\n
  4. When we are adding a new photo, create a new MLE object on the client, set any properties, and add the object to the DataServiceContext<\/a>. <\/li>\n
  5. Read an image from the local computer into a stream, pass the stream and the object to the SetSaveStream<\/a> method, and then call SaveChanges<\/a>. <\/li>\n<\/ol>\n

    As you may recall, the PhotoData sample data service exposes a single PhotoInfo<\/strong> entity (an MLE) which has a related image file (the MR). The HasStream<\/strong> attribute applied to the PhotoInfo<\/strong> entity tells the client that it is an MLE, as you can see in the PhotoInfo<\/strong> entity metadata returned by the data service:
    <\/p>\n

    Now, let\u2019s get started on creating the client application. <\/p>\n

    Creating the WPF Client Application<\/h3>\n

    Our client application is a Windows Presentation Foundation (WPF) application. This enables us to use data binding of PhotoInfo<\/strong> objects to UI elements. <\/p>\n

    First let\u2019s create the WPF client application (I won\u2019t go into too much detail here\u2026you can review the XAML that defines these windows in the client project included with the sample PhotoData streaming data service<\/a>):<\/p>\n

      \n
    1. Create the WPF project. <\/li>\n
    2. Use the Add Service Reference<\/strong> dialog in Visual Studio to add a reference to the PhotoData service that we implemented in the previous post<\/a>. <\/li>\n
    3. The PhotoWindow<\/strong> displays the FileName<\/strong> property of the PhotoInfo objects materialized from the data feed in the photoComboBox<\/strong>: \n
      \n

      \"image\"<\/a> <\/p>\n<\/blockquote>\n

      When one of the PhotoInfo<\/strong> objects is selected, by file name, from the photoComboBox<\/strong>, the related image MR is requested from the data service and displayed as an image in the page. <\/li>\n

    4. The PhotoDetailsWindow<\/strong> displays the properties of the selected PhotoInfo<\/strong> object: \n
      \n

      \"image\"<\/a> <\/p>\n<\/blockquote>\n

      This window is displayed when you click Add Photo<\/strong> or Photo Details<\/strong> in the PhotoWindow<\/strong>. <\/li>\n<\/ol>\n

      Now let\u2019s see how the MLE and MR data from the data service is propagated into these UI elements. <\/p>\n

      Querying the Data Service and Displaying the Streamed Data<\/h3>\n

      The following steps are required to query the PhotoData service for the data feed and get images for a specific PhotoInfo<\/strong> object.<\/p>\n

        \n
      1. Declare the DataServiceContext<\/a> used to access the data service and the DataServiceCollection<\/a> used for data binding: \n
        \n

        private PhotoDataContainer context;
        private DataServiceCollection<PhotoInfo> trackedPhotos;
        private PhotoInfo currentPhoto; <\/font><\/p>\n

        \/\/ Get the service URI from the settings file.
        private Uri svcUri =
            new Uri(Properties.Settings.Default.svcUri);<\/font><\/p>\n<\/blockquote>\n

        Note that the data service URI is stored in the app.config file. <\/li>\n

      2. When the PhotoWindow<\/strong> is loaded, execute the query that loads the binding collection with objects from the PhotoInfo<\/strong> feed returned by the data service: \n
        \n

        \/\/ Define a query that returns a feed with all PhotoInfo objects.
        var query = context.PhotoInfo; <\/font><\/p>\n

        \/\/ Create a new collection for binding based on the executed query.
        trackedPhotos = new DataServiceCollection<PhotoInfo>(query); <\/font><\/p>\n

        \/\/ Load all pages of the response into the binding collection.
        while (trackedPhotos.Continuation != null)
        {
            trackedPhotos.Load(
                context.Execute<PhotoInfo>(trackedPhotos.Continuation.NextLinkUri));
        }<\/font><\/p>\n

        <\/font><\/p>\n<\/blockquote>\n<\/li>\n

      3. When the user selects a file name from the photoComboBox<\/strong>, call the GetReadStreamUri<\/a> method to request the MR from the data service, as follows: \n
        \n

        \/\/ Use the ReadStreamUri of the Media Resource for selected PhotoInfo object
        \/\/ as the URI source of a new bitmap image.
        photoImage.Source = new BitmapImage(context.GetReadStreamUri(currentPhoto));<\/font><\/p>\n

        <\/font><\/p>\n<\/blockquote>\n

        The returned URI is used to create the image on the client that is displayed in the UI. <\/p>\n

        \n

        Note:<\/strong> The URI of the MR works very well for creating an image on the client. However, when you need the MR returned as a binary stream instead of just the URI, you must instead use the GetReadStream<\/a> method. This method returns a DataServiceStreamResponse<\/a> object that contains the binary stream of MR data, accessible from the Stream<\/a> property.<\/p>\n<\/blockquote>\n<\/li>\n<\/ol>\n

        Uploading a New Image to the Data Service <\/h3>\n

        The following steps are required to create a new PhotoInfo<\/strong> entity and binary image file in the data service.<\/p>\n

          \n
        1. When adding a new photo, we must create a new MLE object on the client. We do this by calling DataServiceCollection<\/a>.Add<\/a> in the PhotoWindow<\/strong> code-behind page: \n
          \n

          \/\/ Create a new PhotoInfo object.
          PhotoInfo newPhotoEntity = new PhotoInfo(); <\/font><\/p>\n

          \/\/ Ceate an new PhotoDetailsWindow instance with the current
          \/\/ context and the new photo entity.
          PhotoDetailsWindow addPhotoWindow =
              new PhotoDetailsWindow(newPhotoEntity, context); <\/font><\/p>\n

          addPhotoWindow.Title = "Select a new photo to upload…"; <\/font><\/p>\n

          \/\/ We need to have the new entity tracked to be able to
          \/\/ call DataServiceContext.SetSaveStream.
          trackedPhotos.Add(newPhotoEntity); <\/font><\/p>\n

          \/\/ If we successfully created the new image, then display it.
          if (addPhotoWindow.ShowDialog() == true)
          {
              \/\/ Set the index to the new photo.
              photoComboBox.SelectedItem = newPhotoEntity;
          }
          else
          {
              \/\/ Remove the new entity since the add operation failed.
              trackedPhotos.Remove(newPhotoEntity);
          }<\/font><\/p>\n<\/blockquote>\n

          This code instantiates and displays the PhotoDetailsWindow<\/strong> to sets properties of the new PhotoInfo<\/strong> object and the binary stream. When we are updating an existing PhotoInfo<\/strong> object, we just pass the existing PhotoInfo<\/strong> object. In this case, we pass a new PhotoInfo<\/strong> object, but we don\u2019t need to call AddObject<\/a> on the context because we are using a DataServiceCollection<\/a> for data binding. <\/li>\n

        2. In the code-behind for the PhotoDetailsWindow<\/strong>, we use a FileStream to read an image from the local computer and pass this stream and the PhotoInfo<\/strong> object to the SetSaveStream<\/a> method: \n
          \n

          \/\/ Create a dialog to select the image file to stream to the data service.
          Microsoft.Win32.OpenFileDialog openImage = new Microsoft.Win32.OpenFileDialog();
          openImage.FileName = "image";
          openImage.DefaultExt = ".*";
          openImage.Filter = "Images File|*.jpg;*.png;*.gif;*.bmp";
          openImage.Title = "Select the image file to upload…";
          openImage.Multiselect = false;
          openImage.CheckFileExists = true; <\/font><\/p>\n

          \/\/ Reset the image stream.
          imageStream = null; <\/font><\/p>\n

          try
          {
              if (openImage.ShowDialog(this) == true)
              {
                  if (photoEntity.PhotoId == 0)
                  {
                      \/\/ Set the image name from the selected file.
                      photoEntity.FileName = openImage.SafeFileName; <\/font><\/p>\n

                      photoEntity.DateAdded = DateTime.Today; <\/font><\/p>\n

                      \/\/ Set the content type and the file name for the slug header.
                      photoEntity.ContentType =
                          GetContentTypeFromFileName(photoEntity.FileName);
                  } <\/font><\/p>\n

                  photoEntity.DateModified = DateTime.Today; <\/p>\n

                  \/\/ Use a FileStream to open the existing image file.
                  imageStream = new FileStream(openImage.FileName, FileMode.Open); <\/font><\/p>\n

                  photoEntity.FileSize = (int)imageStream.Length; <\/font><\/p>\n

                  \/\/ Create a new image using the memory stream.
                  BitmapImage imageFromStream = new BitmapImage();
                  imageFromStream.BeginInit();
                  imageFromStream.StreamSource = imageStream;
                  imageFromStream.CacheOption = BitmapCacheOption.OnLoad;
                  imageFromStream.EndInit(); <\/font><\/p>\n

                  \/\/ Set the height and width of the image.
                  photoEntity.Dimensions.Height = (short?)imageFromStream.PixelHeight;
                  photoEntity.Dimensions.Width = (short?)imageFromStream.PixelWidth; <\/font><\/p>\n

                  \/\/ Reset to the beginning of the stream before we pass it to the service.
                  imageStream.Position = 0; <\/font><\/p>\n

                  \/\/ Set the file stream as the source of binary stream
                  \/\/ to send to the data service. The Slug header is the file name and
                  \/\/ the content type is determined from the file extension.
                  \/\/ A value of ‘true’ means that the stream is closed by the client when
                  \/\/ the upload is complete. 
                  context.SetSaveStream(photoEntity, imageStream, true,
                      photoEntity.ContentType, photoEntity.FileName); <\/font><\/p>\n

                  return true;
              }
              else
              {
                  MessageBox.Show("The selected file could not be opened.");
                  return false;
              }
          }
          catch (IOException ex)
          {
              MessageBox.Show(
                  string.Format("The selected image file could not be opened. {0}",
                  ex.Message), "Operation Failed");
              return false;
          }<\/font><\/p>\n<\/blockquote>\n

                                Note that we use the image stream to create a new BitmapImage<\/strong>, which is only used to automatically set the height and width properties of the image. <\/li>\n

        3. When the savePhotoDetails<\/strong> button in the PhotoDetailsWindow<\/strong> is clicked, we call SaveChanges<\/a> to send the MR as a binary stream (and any PhotoInfo<\/strong> object updates) to the data service: \n
          \n

          \/\/ Send the update (POST or MERGE) request to the data service and
          \/\/ capture the added or updated entity in the response.
          ChangeOperationResponse response =
              context.SaveChanges().FirstOrDefault() as ChangeOperationResponse; <\/font><\/p>\n<\/blockquote>\n

          When SaveChanges<\/a> is called to create a new photo, the client sends a POST request to create the MR in the data service using the supplied stream. After it processes the stream, the data service creates an empty MLE. The client then sends a subsequent MERGE request to update this new PhotoInfo<\/strong> entity with data from the client. <\/li>\n

        4. When uploading a new photo (POST), we also need need to execute a query to get the new media link entry by using a MergeOption.OverwriteChanges<\/a> to update the client object instance to to get all of the data from the newly created MLE from the data service, as follows. \n
          \n

          \/\/ When we issue a POST request, the photo ID and edit-media link are not updated
          \/\/ on the client (a bug), so we need to get the server values.
          if (photoEntity.PhotoId == 0)
          {
              if (response != null)
              {
                  entity = response.Descriptor as EntityDescriptor;
              } <\/font><\/p>\n

              \/\/ Verify that the entity was created correctly.
              if (entity != null && entity.EditLink != null)
              {
                  \/\/ Cache the current merge option (we reset to the cached
                  \/\/ value in the finally block).
                  cachedMergeOption = context.MergeOption; <\/font><\/p>\n

                  \/\/ Set the merge option so that server changes win.
                  context.MergeOption = MergeOption.OverwriteChanges; <\/font><\/p>\n

                  \/\/ Get the updated entity from the service.
                  \/\/ Note: we need Count() just to execute the query.
                  context.Execute<PhotoInfo>(entity.EditLink).Count();
              }
          }<\/font><\/p>\n

          <\/font><\/p>\n<\/blockquote>\n

          We have to do this because of a limitation in the WCF Data Services client POST behavior where it does not update the object on the client with the server-generated values or the edit-media link URI. <\/li>\n<\/ol>\n

          <\/font><\/p>\n

          Glenn Gailey <\/strong><\/font>
          <\/font>Senior Programming Writer
          WCF Data Services<\/p>\n","protected":false},"excerpt":{"rendered":"

          In this second post in the series on implementing a streaming data provider, we show how to use the WCF Data Services client library to access binary data exposed by an Open Data Protocol (OData) feed, as well as has how to upload binary data to the data service. For more information on the streaming […]<\/p>\n","protected":false},"author":512,"featured_media":3253,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[23,42,48,70,78],"class_list":["post-1153","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-odata","tag-data-services","tag-media-resource","tag-odata","tag-streaming","tag-wcf-data-services"],"acf":[],"blog_post_summary":"

          In this second post in the series on implementing a streaming data provider, we show how to use the WCF Data Services client library to access binary data exposed by an Open Data Protocol (OData) feed, as well as has how to upload binary data to the data service. For more information on the streaming […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/posts\/1153","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/users\/512"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/comments?post=1153"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/posts\/1153\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/media\/3253"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/media?parent=1153"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/categories?post=1153"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/odata\/wp-json\/wp\/v2\/tags?post=1153"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}