Silverlight File Upload Best Practices and Common Pitfalls

Troubleshooting Silverlight File Upload Errors and Performance Issues

Overview

This article guides you through diagnosing and fixing common errors and performance bottlenecks when implementing file uploads in Silverlight applications. It covers client-side checks, server-side configuration, network considerations, and performance tuning to help ensure reliable, efficient uploads.

Common Upload Errors and How to Fix Them

1. File selection or dialog fails to open

• Cause: Browser security restrictions or missing Silverlight object.
• Fixes:
  • Ensure the Silverlight plugin is installed and enabled in the browser.
  • Confirm your application triggers the OpenFileDialog from a user-initiated event (click or keypress). Browsers block programmatic file dialogs.
  • Test in multiple browsers to isolate plugin vs. app issues.

2. “Access Denied” or cross-domain errors

• Cause: Upload target is on a different domain and cross-domain policy not configured.
• Fixes:
  • Place a valid clientaccesspolicy.xml and/or crossdomain.xml at the root of the target domain.
  • Ensure the policy allows the required HTTP methods (POST/PUT) and headers.
  • Verify policy file is served with correct MIME type and reachable via direct URL.

3. File size limits or truncated uploads

• Cause: Server-side request size limits, Silverlight max buffer, or proxy restrictions.
• Fixes:
  • On IIS, increase maxAllowedContentLength (requestFiltering) and maxRequestLength (system.web) as needed.
  • For WCF, set maxReceivedMessageSize and maxBufferSize, and adjust readerQuotas.
  • If using HTTP handlers, ensure buffering settings accommodate large files or implement streaming.
  • Check intermediate proxies/load balancers for upload size limits.

4. Timeouts during large uploads

• Cause: Default request timeouts on server or proxies; inefficient client buffering.
• Fixes:
  • Increase executionTimeout in ASP.NET or relevant timeout settings in WCF bindings (receiveTimeout, sendTimeout).
  • Use chunked uploads: split files into smaller blocks, upload sequentially or in parallel, and reassemble server-side.
  • Implement resumable uploads with checksums to allow retries without restarting.

5. Corrupted files on server

• Cause: Incorrect encoding, double-buffering, or improper stream handling.
• Fixes:
  • Ensure uploads use binary mode and avoid unintended encoding conversions (no text-based transforms).
  • Use streams correctly: read/write exact bytes, flush and close streams, and validate length.
  • Compare client and server checksums (MD5/SHA256) post-upload to detect corruption.

6. Unexpected exceptions in WCF services

• Cause: Unhandled exceptions, serialization errors, or binding misconfiguration.
• Fixes:
  • Enable detailed logging and trace on WCF (only in development) to capture exception stacks.
  • Ensure DataContracts are properly attributed and serializable types are used.
  • Match client and server binding configurations (transferMode, maxReceivedMessageSize, etc.).

Performance Issues and Optimizations

1. Reduce memory usage on client and server

• Use streaming APIs instead of buffering entire file in memory.
• In Silverlight, read and upload files in chunks (e.g., 64–256 KB) rather than loading full byte arrays.
• On server, process streams directly and avoid temporary full-file buffering when possible.

2. Use efficient network strategies

• Enable compression where appropriate for compressible content (text-based files), but avoid compressing already-compressed media.
• Prefer asynchronous uploads to keep UI responsive; show progress indicators and allow cancellation.
• For high-latency networks, reduce round-trips by increasing chunk size within memory limits.

3. Parallelism and throttling

• Upload multiple chunks in parallel to utilize bandwidth better, but implement a cap (e.g., 3–5 concurrent uploads) to avoid saturating client CPU or server connections.
• Implement server-side throttling or connection limits to protect resources under load.

4. Server-side scaling

• Offload file storage to dedicated services (cloud object storage, CDN) rather than keeping uploads on web servers.
• Use distributed processing or background workers for post-upload tasks (virus scanning, transcoding).
• Employ sticky sessions or centralized session/state (e.g., Redis) if chunked uploads require session affinity.

Diagnostics Checklist (Quick)

• Confirm Silverlight plugin and app permissions.
• Reproduce issue, capture exact error messages and browser console logs.
• Check clientaccesspolicy.xml / crossdomain.xml availability.
• Review server logs, request size and timeout settings.
• Verify WCF/HTTP binding settings and reader quotas.
• Test with varied file sizes, types, and network conditions.
• Implement checksum verification to detect corruption.

Example: Implementing Chunked Uploads (High-level)

1. On client: open file, read in N-byte chunks, POST each chunk with metadata (file ID, chunk index, total chunks).
2. On server: receive chunk, append to temporary file or store chunk in object store, track received chunks.
3. On final chunk: validate checksum, assemble final file if needed, move to permanent storage and respond with success.
4. On failure: support retry of individual chunks; allow resume by reporting which chunks are present.

Monitoring and Logging Recommendations

• Log upload start/end, client IP (anonymize if required), file size, duration, and any errors.
• Capture per-chunk metrics for chunked uploads: retries, latency, throughput.
• Set alerts for elevated error rates, long median upload times, or storage failures.

Closing Notes

Follow the checklist and progressively apply fixes: start with client-side validation, confirm cross-domain policies, adjust server limits/timeouts, then add chunking and streaming for robust large-file support. Use logging and metrics to identify remaining bottlenecks and validate improvements.