/// <summary>
 /// Constructor for the ClientProxy class.
 /// Allocates an instance of the real web service client.
 /// </summary>
 /// <param name="webService">Web service proxy.</param>
 /// <param name="operationTimeoutMinutes">Operation timeout to set in the client. Unit is minutes.</param>
 /// <param name="operationTimeoutSeconds">Operation timeout to set in the client. Unit is seconds.</param>
 public ClientProxy(PictureServiceProxy webService,
                    Int32 operationTimeoutMinutes,
                    Int32 operationTimeoutSeconds = 0)
 {
     _operationTimeout = (operationTimeoutMinutes * 60) + operationTimeoutSeconds;
     _webService       = webService;
     _client           = (PictureServiceClient)(_webService.PopClient(_operationTimeout));
     _webService.SetTimeout(Client.Endpoint.Binding, _operationTimeout);
 }
Example #2
0
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            _pictureServiceClient = new PictureServiceClient("CustomBinding_IPictureService");
            _pictureServiceClient.UploadImageCompleted += Client_UploadImageCompleted;
            _cameras = WebCamera.Devices();

            LoadIntervals();
            LoadCameraList();
        }
        public MainWindow()
        {
            _client = new PictureServiceClient();

            _timer = new DispatcherTimer
            {
                Interval = new TimeSpan(0, 0, 0, 1)
            };
            _timer.Tick += TimerTick;
            _timer.Start();
        }
Example #4
0
        static void Main(string[] args)
        {
            //string filePath = @"C:\Users\Public\Pictures\Sample Pictures\desert.jpg";
            string filePath = @"C:\wcftest\test.txt";

            Picture pictureToUpload = new Picture();
            //pictureToUpload.Name = "desert.jpg";
            pictureToUpload.Name = "test.txt";
            pictureToUpload.PictureStream =  File.ReadAllBytes(filePath);

            PictureServiceClient client = new PictureServiceClient();
            client.UploadPicture(pictureToUpload);
        }
        /// <summary>
        /// Create a web service client.
        /// </summary>
        /// <returns>A web service client.</returns>
        protected override Object CreateClient()
        {
            PictureServiceClient client;

            client = new PictureServiceClient(GetBinding(),
                                              GetEndpointAddress());

            // Increase data size for all methods that
            // sends or receives a lot of data.
            IncreaseDataSize("CreatePictureFilename", client.Endpoint);
            IncreaseDataSize("GetPictureById", client.Endpoint);
            IncreaseDataSize("GetPictureByPictureFilename", client.Endpoint);
            IncreaseDataSize("GetPictureByPictureStringId", client.Endpoint);
            IncreaseDataSize("GetPictureBySearchCriteria", client.Endpoint);
            IncreaseDataSize("GetPictureInformationById", client.Endpoint);
            IncreaseDataSize("GetPicturesByIds", client.Endpoint);
            IncreaseDataSize("GetPicturesInformationBySearchCriteria", client.Endpoint);
            IncreaseDataSize("UpdatePictures", client.Endpoint);

            return(client);
        }
        private async void OpenFileClick(object sender, RoutedEventArgs e)
        {
            PictureServiceClient oPicture = new PictureServiceClient();
            PictureFile pictureFile = new PictureFile();

            var filePicker = new FileOpenPicker();
            filePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
            filePicker.ViewMode = PickerViewMode.Thumbnail;
            filePicker.FileTypeFilter.Add(".jpg");
            filePicker.FileTypeFilter.Add(".png");
            filePicker.FileTypeFilter.Add(".bmp");
            filePicker.FileTypeFilter.Add(".gif");

            

            if (chkMultipleFiles.IsChecked.Value)
            {
                IAsyncOperation<IReadOnlyList<StorageFile>> asyncOp = filePicker.PickMultipleFilesAsync();
                IReadOnlyList<StorageFile> fileList = await asyncOp;

                if (fileList != null)
                {
                    var myPictures = new List<MyPicture>();

                    foreach (var file in fileList)
                    {
                        using (IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) 
                        {
                            var image = new BitmapImage();
                            image.SetSource(stream);
                            myPictures.Add(new MyPicture { PictureImage = image });
                        };                        
                    }

                    gvPictures.ItemsSource = myPictures;
                }
            }
            else
            {
                IAsyncOperation<StorageFile> asyncOp = filePicker.PickSingleFileAsync();
                StorageFile file = await asyncOp;

                if (file != null)
                {
                    using (IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
                    {
                        BitmapImage image = new BitmapImage();
                        image.SetSource(stream);

                        IBuffer buffer = await FileIO.ReadBufferAsync(file);

                        byte[] pixeBuffer = buffer.ToArray();

                        pictureFile.PictureStream = pixeBuffer;
                        pictureFile.PictureName = file.Name;

                        bool rpta = await oPicture.UploadAsync(pictureFile);

                        var myPictures = new MyPicture[] { new MyPicture { PictureImage = image } };
                        gvPictures.ItemsSource = myPictures;

                    }; 
                    
                }
            }

        }