|
public GetByteArrayAsync ( |
||
| requestUri | ||
| return | Task |
|
async private void loadJsonInfo()
{
try
{
//--------- Having content from website--------------
HttpClient http = new HttpClient();
var response = await http.GetByteArrayAsync("http://emresevinc.github.io/exrepo.html");
String source = Encoding.GetEncoding("utf-8").GetString(response, 0, response.Length - 1);
source = WebUtility.HtmlDecode(source);
HtmlDocument resultat = new HtmlDocument();
resultat.LoadHtml(source);
List<HtmlNode> toftitle = resultat.DocumentNode.Descendants().Where
(x => (x.Name == "div" && x.Attributes["class"] != null &&
x.Attributes["class"].Value.Contains("container"))).ToList();
String text = toftitle[0].InnerText;
selectedMovie = new Movie();
//----------------------------------------------------
_jObject = JsonObject.Parse(text); // Burada json dosyası parse ediliyor.
jArr = _jObject.GetNamedArray("movies"); // Json verileri içindeki movies array'i
fillToMovieList();
}
catch (Exception)
{
new MessageDialog("Bir hata gerceklesti").ShowAsync();
}
}
protected Downloads.File GetFileStream(Downloads.File file)
{
using (var client = new HttpClient()) {
try {
var data = client.GetByteArrayAsync(file.DownloadUrl).Result;
if (data.Length > 0) {
var result = data.ToArray();
MemoryStream ms = new MemoryStream();
ms.Write(data, 0, data.Length);
ms.Position = 0;
file.FileStream = ms;
file.IsValidFile = true;
ms.Flush();
} else {
throw new Exception("Error: Unable to download file");
}
} catch (AggregateException ex) {
//log error
ex.ToString();
}
}
return file;
}
private async Task Download(string url,StorageFile file,bool cover)
{
var http = new HttpClient();
byte[] response = { };
string betterUrl = url;
if(cover)
{
var pos = betterUrl.IndexOf(".jpg");
if (pos != -1)
betterUrl = betterUrl.Insert(pos, "l");
}
//get bytes
try
{
await Task.Run(async () => response = await http.GetByteArrayAsync(betterUrl));
}
catch (Exception)
{
await Task.Run(async () => response = await http.GetByteArrayAsync(url));
}
var fs = await file.OpenStreamForWriteAsync(); //get stream
var writer = new DataWriter(fs.AsOutputStream());
writer.WriteBytes(response); //write
await writer.StoreAsync();
await writer.FlushAsync();
writer.Dispose();
}
public async Task StreamsReadFromSamePositionEachRequest()
{
var bytes = new byte[]
{
121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109, 47, 112, 108, 97, 121, 108, 105, 115, 116, 63, 108,
105, 115, 116, 61, 80, 76, 89, 111, 111, 69, 65, 70, 85, 102, 104, 68, 102, 101, 118, 87, 70, 75, 76,
97, 55, 103, 104, 51, 66, 111, 103, 66, 85, 65, 101, 98, 89, 79
};
int offsetStreamPosition = 39;
byte[] expectedOffsetBytes = bytes.Skip(offsetStreamPosition).ToArray();
using (MemoryStream stream = new MemoryStream(bytes))
using (MemoryStream offsetStream = new MemoryStream(bytes))
{
handler.SetupRequest(HttpMethod.Get, "https://example.com/normal")
.ReturnsResponse(stream);
// Multiple setups can share the same stream as well
handler.SetupRequest(HttpMethod.Get, "https://example.com/normal2")
.ReturnsResponse(stream);
// This stream is the same but seeked forward; each request should read from this position rather than
// seeking back to the beginning
offsetStream.Seek(offsetStreamPosition, SeekOrigin.Begin);
handler.SetupRequest(HttpMethod.Get, "https://example.com/offset")
.ReturnsResponse(offsetStream);
var responseBytes1 = await client.GetByteArrayAsync("normal");
var responseBytes2 = await client.GetByteArrayAsync("normal");
var responseBytes3 = await client.GetByteArrayAsync("normal2");
var offsetResponseBytes1 = await client.GetByteArrayAsync("offset");
var offsetResponseBytes2 = await client.GetByteArrayAsync("offset");
responseBytes1.Should().BeEquivalentTo(bytes);
responseBytes2.Should().BeEquivalentTo(bytes,
"the stream should be returned to its original position after being read");
responseBytes3.Should().BeEquivalentTo(bytes,
"the stream should be reusable not just between requests to one setup but also between setups");
offsetResponseBytes1.Should().BeEquivalentTo(expectedOffsetBytes,
"the stream should read from its initial (offset) position, not necessarily the beginning");
offsetResponseBytes2.Should().BeEquivalentTo(expectedOffsetBytes,
"the stream should be returned to its original (offset, not zero) position after being read");
}
}
/// <summary>
/// Parser article from URL.
/// </summary>
/// <param name="url">URL</param>
/// <returns></returns>
public static String Parse(String url)
{
String source;
byte[] response;
HtmlNode content;
HttpClient client;
HtmlDocument document;
List<String> sentences;
sentences = new List<String>();
client = new HttpClient();
response = client.GetByteArrayAsync(url).Result;
source = Encoding.GetEncoding("utf-8").GetString(response, 0, response.Length - 1);
source = WebUtility.HtmlDecode(source);
document = new HtmlDocument();
document.LoadHtml(source);
content = document.DocumentNode.Descendants().Where(
x => x.Attributes["id"] != null && x.Attributes["id"].Value.Equals("mw-content-text")).FirstOrDefault();
if (content == null)
return "Unable to parse the source.";
foreach (HtmlNode childNoteLoop in content.ChildNodes)
{
if (childNoteLoop.Name == "div" && childNoteLoop.Id == "toc")
break;
if (childNoteLoop.Name == "p")
sentences.Add(childNoteLoop.InnerText.Trim());
}
return String.Join(NotenizerConstants.WordDelimeter, sentences);
}
/// <summary>
/// Concurrently requests the given <paramref name="target"/> <paramref name="requestCount"/> times.
/// </summary>
/// <param name="target">Uri to torture.</param>
/// <param name="requestCount">Number of requests.</param>
/// <param name="concurrentRequestLimit">Maximum number of concurrent requests.</param>
public static async Task<TortureResult> TortureAsync(Uri target, Int64 requestCount, Int64 concurrentRequestLimit = 22)
{
Int64 bytesRead = 0;
Stopwatch stopwatch = Stopwatch.StartNew();
var pendingTasks = new List<Task<Byte[]>>();
using (HttpClient client = new HttpClient())
{
for (Int64 index = 0; index < requestCount; index++)
{
Task<Byte[]> fetchTask = client.GetByteArrayAsync(target);
pendingTasks.Add(fetchTask);
if (pendingTasks.Count > concurrentRequestLimit)
{
foreach (var task in pendingTasks.ConsumeWhere(null))
{
Byte[] result = await task.ConfigureAwait(false);
bytesRead += result.LongLength;
}
}
}
foreach (var task in pendingTasks.ConsumeWhere(null))
{
Byte[] result = await task.ConfigureAwait(false);
bytesRead += result.LongLength;
}
}
return new TortureResult { Target = target, RequestCount = requestCount, BytesRead = bytesRead, TimeElapsed = stopwatch.Elapsed };
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
Button AsyncButton = FindViewById<Button> (Resource.Id.btnAsync);
Button ParallelButton = FindViewById<Button> (Resource.Id.btnParallel);
TextView LabelSize = FindViewById<TextView> (Resource.Id.lblSize);
ImageView ImageDonwloaded = FindViewById<ImageView> (Resource.Id.imageD);
CheckBox ckbHUD = FindViewById<CheckBox> (Resource.Id.checkBoxHUD);
var showHUD = false;
ParallelButton.Click += (sender, e) => {
showHUD = ckbHUD.Checked;
Task.Factory.StartNew(()=>{
if(showHUD)
AndHUD.Shared.Show(this, "Downloading Image via Parallel", -1, MaskType.Clear);
var httpClient = new HttpClient();
byte[] imageBytes = httpClient.GetByteArrayAsync("http://upload.wikimedia.org/wikipedia/commons/6/66/Big_size_chess_6759_CRI_08_2009_Langosta_Beach.jpg").Result;
return imageBytes;
}).ContinueWith(res=>{
string documents = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
string localPath = System.IO.Path.Combine (documents, "image.png");
File.WriteAllBytes (localPath, res.Result);
var localImage = new Java.IO.File (localPath);
if (localImage.Exists ()) {
var teamBitmap = BitmapFactory.DecodeFile (localImage.AbsolutePath);
RunOnUiThread(()=>{
LabelSize.Text = string.Format("Size: {0} MB", ConvertBytesToMegabytes(res.Result.Length));
ImageDonwloaded.SetImageBitmap (teamBitmap);
});
}
if(showHUD)
AndHUD.Shared.Dismiss(this);
});
};
AsyncButton.Click += async (sender, e) => {
showHUD = ckbHUD.Checked;
if(showHUD)
AndHUD.Shared.Show(this, "Downloading Image via Async/Await", -1, MaskType.Clear);
var httpClient = new HttpClient();
byte[] imageBytes = await httpClient.GetByteArrayAsync("http://upload.wikimedia.org/wikipedia/commons/6/66/Big_size_chess_6759_CRI_08_2009_Langosta_Beach.jpg");
string documents = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
string localPath = System.IO.Path.Combine (documents, "image.png");
File.WriteAllBytes (localPath, imageBytes);
var localImage = new Java.IO.File (localPath);
if (localImage.Exists ()) {
var teamBitmap = BitmapFactory.DecodeFile (localImage.AbsolutePath);
LabelSize.Text = string.Format("Size: {0} MB", ConvertBytesToMegabytes(imageBytes.Length));
ImageDonwloaded.SetImageBitmap (teamBitmap);
}
if(showHUD)
AndHUD.Shared.Dismiss(this);
};
}
async void BeginReadCCTV()
{
IsBeginRead = true;
ISExit = false;
tblCCTV cctvinfo=null;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
cctvinfo = this.DataContext as tblCCTV;
});
// client=new HttpClient();
while (!ISExit)
{
try
{
Uri uri = new Uri("http://192.192.161.3/" + cctvinfo.REF_CCTV_ID.Trim() + ".jpg?" + rnd.Next(), UriKind.Absolute);
using (httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(0.5);
var contentBytes = await httpClient.GetByteArrayAsync(uri);
var ims = new InMemoryRandomAccessStream();
var dataWriter = new DataWriter(ims);
dataWriter.WriteBytes(contentBytes);
await dataWriter.StoreAsync();
//ims.seak 0
ims.Seek(0 );
await Dispatcher.RunAsync( Windows.UI.Core.CoreDispatcherPriority.Normal,()=>
{
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(ims );
this.imgCCTV.Source = bitmap;
imginx = (imginx + 1) % 90000;
this.RunFrameRate.Text = imginx.ToString();
});
}
}
catch (Exception ex)
{
// this.textBlock1.Text = ex.Message;
}
// BitmapImage img = new BitmapImage();
// img.SetSource(stream);
}
}
private async Task<List<string>> GetCsvData(Uri csvLink)
{
HttpClient request = new HttpClient();
var csv = Encoding.GetEncoding("latin1").GetString(await request.GetByteArrayAsync(csvLink));
var lines = csv.Split(new string[] { "\r\n", "\n", "\r" }, StringSplitOptions.None);
return lines.Skip(1).ToList();
}
public async static Task<byte[]> GetByteArrayAsync(string url)
{
using (var httpClient = new HttpClient(new ModernHttpClient.NativeMessageHandler()))
{
return await httpClient.GetByteArrayAsync(url);
}
}
public Task<byte[]> DownloadFromUri(string uri)
{
//HttpWebRequest httpWebRequest = (HttpWebRequest)HttpWebRequest.Create(uri);
//using (HttpWebResponse httpWebReponse = (HttpWebResponse)httpWebRequest.GetResponse())
//{
// using (Stream stream = httpWebReponse.GetResponseStream())
// {
// var memoryStream = new MemoryStream();
// stream.CopyTo(memoryStream);
// return memoryStream.ToArray();
// }
//}
return Task.Run(async () =>
{
using (var client = new HttpClient())
{
// var stream = client.GetStreamAsync("https://scontent-frt3-1.xx.fbcdn.net/hphotos-xat1/v/t1.0-9/12289642_1183804578301916_8282521644435051935_n.jpg?oh=3f6d4458591beda5ca286d4269ecb865&oe=5724CC7F");
var rawresponse = await client.GetByteArrayAsync(uri);
return rawresponse;// TODO:
}
});
}
private static async Task DownloadFromOfficial(string fileName, string imageUrl, string relevantPart)
{
using (var client = new HttpClient())
{
var imgData = await client.GetByteArrayAsync(imageUrl).ConfigureAwait(false);
CreateDirectories(fileName);
using (var ms = new MemoryStream(imgData))
using (var image = Image.FromStream(ms))
{
try
{
using (var outputStream = File.Create(fileName, 65536, FileOptions.Asynchronous))
{
image.Save(outputStream, ImageFormat.Png);
}
Log.InfoFormat("Downloaded item image {0} to the file system.", relevantPart);
return;
}
catch (IOException e)
{
Log.Info("File " + relevantPart +
" could not be created. Most likely because it was created from another thread.", e);
Log.Info("Waiting 1 sec for the other thread to finish.");
}
// No await in catch
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
}
}
}
private async Task saveImageToDisk(Articolo art) // async
{
HttpClient c = new HttpClient();
c.BaseAddress = new Uri(art.UrlImg);
c.Timeout = new TimeSpan(0,0, 3);
Byte[] imgByteArray = await c.GetByteArrayAsync ("");
CancellationToken a = new CancellationToken();
IFolder rootFolder = FileSystem.Current.LocalStorage;
IFolder folder = await rootFolder.CreateFolderAsync("Immagini",
CreationCollisionOption.OpenIfExists);
var listaFilePerVerifica = await folder.GetFilesAsync (new CancellationToken ());
var listafile = await folder.GetFilesAsync ();
IFile file = await folder.CreateFileAsync(art.ImageFileName ,
CreationCollisionOption.ReplaceExisting);
// http://www.mallibone.com/post/storing-files-from-the-portable-class-library-(pcl)
using (var fileHandler = await file.OpenAsync (FileAccess.ReadAndWrite)) {
fileHandler.WriteAsync(imgByteArray, 0, imgByteArray.Length); // await
}
}
private async void DownLoadImage(Uri _ImageUri)
{
HttpClient client = new HttpClient();
byte[] buffer = await client.GetByteArrayAsync(_ImageUri);
// 注意需要把数据流重新复制一份，否则会出现跨线程错误
// 网络下载到的图片数据流，属于后台线程的对象，不能在UI上使用
Stream streamForUI = new MemoryStream();
streamForUI.Write(buffer, 0, buffer.Length);
streamForUI.Seek(0, SeekOrigin.Begin);
//触发UI更新界面
await Page.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
BitmapImage bm = new BitmapImage();
bm.SetSource(streamForUI.AsRandomAccessStream());
//把图像放到弱引用里面
if (null == bitmapImage)
{
bitmapImage = new WeakReference(bm);
}
else
{
bitmapImage.Target = bm;
}
//触发UI绑定属性的改变
OnPropertyChanged("ImageSource");
});
}
public async Task<FileContentResult> GetResizePicture(string file, int width, int height)
{
if (file == "")
return new FileContentResult(new byte[0], "image/png");
var client = new HttpClient();
var response = await client.GetByteArrayAsync(file);
using (var rms = new MemoryStream(response))
{
using (var source = new Bitmap(rms))
{
using (var ms = new MemoryStream())
{
source.Save(ms, ImageFormat.Png);
}
var scale = _resize.DetermineResizeScale(source.Width, source.Height, width, height);
var bytes = _resize.CreateResizedPicture(rms, scale);
return new FileContentResult(bytes, "image/png");
}
}
}
private async Task SumPageSizesAsync()
{
// Declare an HttpClient object and increase the buffer size. The
// default buffer size is 65,536.
HttpClient client =
new HttpClient() { MaxResponseContentBufferSize = 1000000 };
// Make a list of web addresses.
List<string> urlList = SetUpURLList();
var total = 0;
foreach (var url in urlList)
{
// GetURLContents returns the contents of url as a byte array.
//byte[] urlContents = await GetURLContentsAsync(url);
byte[] urlContents = await client.GetByteArrayAsync(url);
DisplayResults(url, urlContents);
// Update the total.
total += urlContents.Length;
}
// Display the total count for all of the web addresses.
resultsTextBox.Text +=
string.Format("\r\n\r\nTotal bytes returned: {0}\r\n", total);
}
public void UploadMessageAsync()
{
var uri = this.UploadMessageHelperAsync().Result;
var client = new HttpClient();
var downloadedBody = client.GetByteArrayAsync(uri).Result;
Assert.Equal(Valid.MessageContent, downloadedBody);
}
/// <summary>
/// Image用 失敗時NULL
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public virtual async Task <byte[]> HttpGetByte(string url, string referer = default(string))
{
await Sleep();
if (ReportUrl)
{
ReportManage.Report(this, "GET " + url, true, true);
}
byte[] data;
try
{
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient(handler, false);
client.DefaultRequestHeaders.UserAgent.ParseAdd(this.UserAgent);
client.DefaultRequestHeaders.Referrer = new Uri(referer);
data = await client.GetByteArrayAsync(url);
}
catch (Exception e)
{
if (visbleErr)
{
ReportManage.ErrReport(this, "Url:" + url + " " + e.Message);
}
data = null;
}
if (data != null)
{
return(data);
}
else
{
return(null);
}
}
public async Task<int> DownloadHomepageAsync()
{
try
{
var httpClient = new HttpClient();
Task<string> contentsTask = httpClient.GetStringAsync("http://xamarin.com");
string contents = await contentsTask;
int length = contents.Length;
ResultTextView.Text += "Downloaded the html and found out the length.\n\n";
byte[] imageBytes = await httpClient.GetByteArrayAsync("http://xamarin.com/images/about/team.jpg");
await SaveBytesToFileAsync(imageBytes, "team.jpg");
ResultTextView.Text += "Downloaded the image.\n";
ResultTextView.Text += "Save the image to a file." + Environment.NewLine;
DownloadedImageView.Image = UIImage.FromFile(localPath);
ALAssetsLibrary library = new ALAssetsLibrary();
var dict = new NSDictionary();
var assetUrl = await library.WriteImageToSavedPhotosAlbumAsync
(DownloadedImageView.Image.CGImage, dict);
ResultTextView.Text += "Saved to album assetUrl = " + assetUrl + "\n";
ResultTextView.Text += "\n\n\n" + contents; // just dump the entire HTML
return length;
}
catch
{
// do something with error
return -1;
}
}
protected override async void OnElementPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(sender, e);
if (e.PropertyName == "Renderer")
{
if (loaded)
return;
var uriImageSource = Element.Source as UriImageSource;
if (uriImageSource == null || uriImageSource.Uri == null)
return;
try
{
loaded = true;
using (var client = new HttpClient())
{
var bytes = await client.GetByteArrayAsync(uriImageSource.Uri);
var sourceRef = CGImageSource.FromData(NSData.FromArray(bytes));
CreateAnimatedImageView (sourceRef, this.Control);
}
}
catch(Exception ex)
{
Console.WriteLine("Unable to load gif: " + ex.Message);
}
}
}
public async Task<int> DownloadHomepageAsync()
{
var httpClient = new HttpClient(); // Xamarin supports HttpClient!
Task<string> contentsTask = httpClient.GetStringAsync("http://xamarin.com"); // async method!
ResultEditText.Text += "DownloadHomepage method continues after async call. . . . .\n";
// await! control returns to the caller and the task continues to run on another thread
string contents = await contentsTask;
// After contentTask completes, you can calculate the length of the string.
int exampleInt = contents.Length;
ResultEditText.Text += "Downloaded the html and found out the length.\n\n\n";
byte[] imageBytes = await httpClient.GetByteArrayAsync("http://xamarin.com/images/about/team.jpg"); // async method!
string documentsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
string localFilename = "team.jpg";
string localPath = Path.Combine (documentsPath, localFilename);
File.WriteAllBytes (localPath, imageBytes); // writes to local storage
ResultTextView.Text += "Downloaded the image.\n";
// ImageView stuff goes here
ResultEditText.Text += contents; // just dump the entire HTML
return exampleInt; // Task<TResult> returns an object of type TResult, in this case int
}
public async Task<string> GetSpeakerImagePath (Conference conference, Speaker speaker)
{
string documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
string localFilename = conference.Slug + "-" + speaker.Slug + ".png";
string localPath = Path.Combine (documentsPath, localFilename);
byte[] bytes = null;
if (!File.Exists (localPath)) {
using (var httpClient = new HttpClient (new NativeMessageHandler ())) {
try {
bytes = await httpClient.GetByteArrayAsync (speaker.ImageUrl);
} catch (OperationCanceledException opEx) {
Insights.Report (opEx);
return null;
} catch (Exception e) {
Insights.Report (e);
return null;
}
//Save the image using writeAsync
FileStream fs = new FileStream (localPath, FileMode.OpenOrCreate);
await fs.WriteAsync (bytes, 0, bytes.Length);
}
}
return localPath;
}
public static async Task<byte[]> Download(string url)
{
Uri uri = new Uri(url);
HttpClient httpClient = new HttpClient();
return await httpClient.GetByteArrayAsync(uri);
}
public async static Task DownloadAndExtractAll(string uri, string dest)
{
var tmpFile = Path.GetTempPath() + "pomelo_" + Guid.NewGuid().ToString() + ".zip";
Console.WriteLine("Downloading from " + uri);
using (var webClient = new HttpClient() { Timeout = new TimeSpan(1, 0, 0), MaxResponseContentBufferSize = 1024 * 1024 * 50 })
{
var bytes = await webClient.GetByteArrayAsync(uri);
File.WriteAllBytes(tmpFile, bytes);
Console.WriteLine("Downloaded");
}
using (var fileStream = new FileStream(tmpFile, FileMode.Open))
using (var archive = new ZipArchive(fileStream))
{
foreach (var x in archive.Entries)
{
if (!Directory.Exists(Path.GetDirectoryName(dest + x.FullName)))
Directory.CreateDirectory(Path.GetDirectoryName(dest + x.FullName));
if (x.Length == 0 && string.IsNullOrEmpty(Path.GetExtension(x.FullName)))
continue;
using (var entryStream = x.Open())
using (var destStream = File.OpenWrite(dest + x.FullName))
{
entryStream.CopyTo(destStream);
}
}
}
File.Delete(tmpFile);
}
public async Task<BitmapImage> BitmapImageAsync(string url)
{
Stream stream = null;
HttpClient WebClient = new HttpClient();
BitmapImage image = new BitmapImage();
try
{
stream = new MemoryStream(await WebClient.GetByteArrayAsync(url));
image.BeginInit();
image.CacheOption = BitmapCacheOption.OnLoad; // here
image.StreamSource = stream;
image.EndInit();
image.Freeze();
}
catch { }
if (stream != null)
{
stream.Close(); stream.Dispose(); stream = null;
}
url = null; WebClient.CancelPendingRequests(); WebClient.Dispose(); WebClient = null;
return image;
}
static async Task<Bitmap> GetRandomKitty() {
var httpClient = new HttpClient(new OkHttpNetworkHandler());
httpClient.Timeout = TimeSpan.FromSeconds(10);
var imageBytes = await httpClient.GetByteArrayAsync(kittyJpgUrl);
Bitmap imageBitmap = await BitmapFactory.DecodeByteArrayAsync(imageBytes, 0, imageBytes.Length);
return imageBitmap;
}
static void Main(string[] args)
{
HttpClient http = new HttpClient();
string webSiteUrl = "http://www.posta.md/ro/tracking?id=RH263108004CN";
var response = http.GetByteArrayAsync(webSiteUrl);
string source = Encoding.GetEncoding("utf-8").GetString(response.Result, 0, response.Result.Length - 1);
source = WebUtility.HtmlDecode(source);
HtmlDocument htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(source);
List<HtmlNode> nodes = htmlDoc.DocumentNode.Descendants().Where(w => (w.Name == "div" && w.Attributes["class"] != null) && w.Attributes["class"].Value.Contains("row clearfix")).ToList();
OrderTracking orderTracking = new OrderTracking();
foreach (HtmlNode node in nodes)
{
orderTracking.AddItem(node);
}
SmppServer smppServer = new SmppServer();
smppServer.ConnectToSmppServerSmsCarrier();
smppServer.SendSms();
Console.ReadLine();
}
/// <summary>
/// 指定したURLから画像データをByte配列で取得します
/// </summary>
/// <param name="url">画像URL</param>
/// <returns>画像データ</returns>
public static async Task<byte[]> DownLoadImageBytesAsync(string url)
{
using (var web = new HttpClient())
{
return await web.GetByteArrayAsync(url).ConfigureAwait(false);
}
}
private async void parsing(string Url)
{
try {
chargement.Visibility = Visibility.Visible;
HttpClient http = new System.Net.Http.HttpClient();
var reponse = await http.GetByteArrayAsync(Url);
str = System.Text.Encoding.GetEncoding("UTF-8").GetString(reponse, 0, reponse.Length - 1);
var strdecode = System.Net.WebUtility.HtmlDecode(str);
HtmlDocument htmldoc = new HtmlDocument();
htmldoc.LoadHtml(strdecode);
var l0 = htmldoc.DocumentNode.Descendants("div").Where(x => (x.Attributes.Contains("id") && String.Equals((String)x.GetAttributeValue("id", "null"), "print_dmname"))).ToList();
var mal = htmldoc.DocumentNode.Descendants("p").ToList();
for (int i = 4; i < 9; i++)
{
mar = mar + mal[i].InnerText;
//+ mal[i].InnerText;
}
Listt.Add(new TextArticle
{
Titre = article.Title,
Text = mar,
Writer = mal[9].InnerText
});
Post.DataContext = Listt;
chargement.Visibility = Visibility.Collapsed;
}
catch
{
MessageDialog mesg = new MessageDialog("Please verify your Internet connection");
mesg.ShowAsync();
}
}
private async void parsing(string Url)
{
try
{
chargement.Visibility = Visibility.Visible;
HttpClient http = new System.Net.Http.HttpClient();
var reponse = await http.GetByteArrayAsync(new Uri(Url));
str = System.Text.Encoding.GetEncoding("UTF-8").GetString(reponse, 0, reponse.Length - 1).ToString();
var strdecode = System.Net.WebUtility.HtmlDecode(str);
HtmlDocument htmldoc = new HtmlDocument();
htmldoc.LoadHtml(strdecode);
var kk = htmldoc.DocumentNode.Descendants("a").ToList();
for (int i = 84; i < 297; i++)
{
ArticleList.Add(new Article
{
Title = kk[i].InnerText,
Url = kk[i].GetAttributeValue("href", null)
});
}
Titles.DataContext = ArticleList;
chargement.Visibility = Visibility.Collapsed;
}
catch
{
MessageDialog mesg = new MessageDialog("Please verify your Internet connection");
mesg.ShowAsync();
}
int j = 0;
}
public async static Task DownloadAndExtract(
string uri,
params Tuple<string, string>[] files)
{
var tmpFile = Path.GetTempPath() + "pomelo_" + Guid.NewGuid().ToString() + ".zip";
Console.WriteLine("Downloading from " + uri);
using (var webClient = new HttpClient() { Timeout = new TimeSpan(1, 0, 0), MaxResponseContentBufferSize = 1024 * 1024 * 50 })
{
var bytes = await webClient.GetByteArrayAsync(uri);
File.WriteAllBytes(tmpFile, bytes);
Console.WriteLine("Downloaded");
}
using (var fileStream = new FileStream(tmpFile, FileMode.Open))
using (var archive = new ZipArchive(fileStream))
{
foreach (var file in files)
{
var entry = archive.GetEntry(file.Item1);
if (entry == null)
throw new Exception("Could not find file '" + file.Item1 + "'.");
Directory.CreateDirectory(Path.GetDirectoryName(file.Item2));
using (var entryStream = entry.Open())
using (var dllStream = File.OpenWrite(file.Item2))
{
entryStream.CopyTo(dllStream);
}
}
}
File.Delete(tmpFile);
}
/// <summary>
/// Get extracted template path from the given templatepath(url) in request body
/// </summary>
/// <param name="TemplateUrl"></param>
/// <param name="ExtractedTemplate"></param>
public string GetTemplateFromPath(string TemplateUrl, string ExtractedTemplate, string GithubToken, string UserID = "", string Password = "")
{
string templatePath = string.Empty;
try
{
Uri uri = new Uri(TemplateUrl);
string fileName = Path.GetFileName(TemplateUrl);
string extension = Path.GetExtension(fileName);
string templateName = ExtractedTemplate.ToLower().Replace(".zip", "").Trim();
if (!Directory.Exists(HostingEnvironment.MapPath("~") + @"\ExtractedZipFile"))
{
Directory.CreateDirectory(HostingEnvironment.MapPath("~") + @"\ExtractedZipFile");
}
var path = HostingEnvironment.MapPath("~") + @"\ExtractedZipFile\" + ExtractedTemplate;
//Downloading template from source of type github
if (uri.Host == "raw.githubusercontent.com")
{
var githubToken = GithubToken;
//var url = TemplateUrl.Replace("github.com/", "raw.githubusercontent.com/").Replace("/blob/master/", "/master/");
using (var client = new System.Net.Http.HttpClient())
{
var credentials = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}:", githubToken);
credentials = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(credentials));
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", credentials);
var contents = client.GetByteArrayAsync(TemplateUrl).Result;
System.IO.File.WriteAllBytes(path, contents);
}
}
//Downloading file from other source type (ftp or https)
else
{
WebClient webClient = new WebClient();
if (UserID != null && Password != null)
{
webClient.Credentials = new NetworkCredential(UserID, Password);
}
webClient.DownloadFile(TemplateUrl, path);
webClient.Dispose();
}
templatePath = ExtractZipFile(path, templateName);
}
catch (Exception ex)
{
ProjectService.logger.Info(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") + "\t" + ex.Message + "\t" + "\n" + ex.StackTrace + "\n");
}
finally
{
var zippath = HostingEnvironment.MapPath("~") + @"\ExtractedZipFile\" + ExtractedTemplate;
if (File.Exists(zippath))
{
File.Delete(zippath);
}
}
return(templatePath);
}
async private Task<BitmapImage> GetImageFromUrlAsync(string url)
{
var client = new HttpClient();
byte[] imageBytes = await client.GetByteArrayAsync(url); // async method!
return ToImage(imageBytes);
}
static string DownloadHtml_Remote(string url)
{
HttpClient http = new HttpClient();
var response = http.GetByteArrayAsync(url);
Task.WaitAll(response);
var source = Encoding.GetEncoding("utf-8").GetString(response.Result, 0, response.Result.Length);
return source;
}
private static byte[] FetchGoogleTile(Uri arg)
{
var httpClient = new System.Net.Http.HttpClient();
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Referer", "http://maps.google.com/");
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", @"Mozilla / 5.0(Windows; U; Windows NT 6.0; en - US; rv: 1.9.1.7) Gecko / 20091221 Firefox / 3.5.7");
return(httpClient.GetByteArrayAsync(arg).ConfigureAwait(false).GetAwaiter().GetResult());
}
public Image GetImageFromUrl(string url)
{
Uri uri = new Uri(Uri.EscapeUriString(url));
byte[] urlContents = _httpClient.GetByteArrayAsync(uri).Result;
string fullName = Path.Combine(CacheImagePath, Guid.NewGuid().ToString());
FileStream fs = new FileStream(fullName, FileMode.OpenOrCreate);
fs.Write(urlContents, 0, urlContents.Length);
return(Image.FromStream(fs));
}
public override byte[] HttpGetByte(string url)
{
this.Sleep();
System.Net.Http.HttpClient client = GetHttpClient();
if (!string.IsNullOrEmpty(this.Referer))
{
client.DefaultRequestHeaders.Referrer = new Uri(this.Referer);
}
var result = client.GetByteArrayAsync(url).ConfigureAwait(false);
return(result.GetAwaiter().GetResult());
}
private static async Task <SolvedCaptcha> CrackCaptcha(DeathByCaptcha.Client dbc_client, HttpClient client, string content)
{
var recaptcha_id = content.Split(new string[] { "Recaptcha.create(\"" }, StringSplitOptions.None)[1]
.Split('\"')[0]
.Trim();
var challenge_response =
await client.GetStringAsync("https://www.google.com/recaptcha/api/challenge?k=" + recaptcha_id);
Regex regexChallenge = new Regex("challenge : '(.*)'");
var match = regexChallenge.Match(challenge_response);
if (!match.Success)
{
return(null);
}
var recaptcha_challenge = match.Groups[1].Value;
var image_response =
await client.GetByteArrayAsync("https://www.google.com/recaptcha/api/image?c=" + recaptcha_challenge);
if (image_response == null)
{
return(null);
}
Captcha captcha = dbc_client.Decode(image_response);
if (captcha.Solved && captcha.Correct)
{
SolvedCaptcha solved = new SolvedCaptcha();
solved.captcha = captcha;
solved.challenge = recaptcha_challenge;
return(solved);
}
else
{
return(null);
}
}
private async void AddSnapshotsAsync(string DeviceId, string clientIP, IEnumerable <XElement> events)
{
if (events.Count() == 0)
{
return;
}
using (var db = new ICMDBContext())
{
foreach (var e in events)
{
if (e.Attribute("time").Value != null)
{
photograph snapshot = new photograph
{
C_srcaddr = DeviceId,
C_time = DateTime.Parse(e.Attribute("time").Value)
};
string imagePath = string.Format("http://{0}/photo?ro={1}&time={2}",
clientIP,
DeviceId,
e.Attribute("time").Value.Replace(" ", "%20"));
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
try
{
snapshot.C_img = await client.GetByteArrayAsync(new Uri(imagePath));
db.Photographs.Add(snapshot);
}
catch (Exception) { }
}
}
try
{
db.SaveChanges();
}
catch (Exception) { }
}
}
private async void parsing(string Url)
{
//try {
chargement.Visibility = Visibility.Visible;
HttpClient http = new System.Net.Http.HttpClient();
var reponse = await http.GetByteArrayAsync(Url);
str = System.Text.Encoding.GetEncoding("UTF-8").GetString(reponse, 0, reponse.Length - 1);
var strdecode = System.Net.WebUtility.HtmlDecode(str);
HtmlDocument htmldoc = new HtmlDocument();
htmldoc.LoadHtml(strdecode);
var AutorList = htmldoc.DocumentNode.Descendants("p").Where(x => (x.Attributes.Contains("class") && String.Equals((String)x.GetAttributeValue("class", "null"), "uk-text-right"))).ToList();
var QuoteList = htmldoc.DocumentNode.Descendants("h3").ToList();
//int n = b.Count
for (int i = 0; i < AutorList.Count(); i++)
{
Temp1.Add(new Template
{
Author = AutorList[i].InnerText.ToString(),
Text = QuoteList[i].InnerText.ToString()
});
}
Qquote.DataContext = Temp1;
chargement.Visibility = Visibility.Collapsed;
if (Temp1.Count == 0)
{
MessageDialog mesg = new MessageDialog("Please verify your Internet connection");
mesg.ShowAsync();
}
//}
//catch
//{
// MessageDialog mesg = new MessageDialog("Please verify your Internet connection");
// mesg.ShowAsync();
//}
}
public async Task <TResponse> Get <TResponse>(string url, NameValueCollection queryString, NameValueCollection headers = null)
where TResponse : class, new()
{
TResponse response = null;
try
{
System.Net.Http.HttpClient client = _httpClient;
if (queryString == null)
{
queryString = new NameValueCollection();
}
url = CreateUrl(url, queryString);
if (headers != null)
{
var keys = headers.AllKeys;
for (var i = 0; i < keys.Length; i++)
{
client.DefaultRequestHeaders.Add(keys[i], headers[keys[i]]);
}
}
//Logger.Debug("请求：{0} {1}", "GET", url);
byte[] rData = await client.GetByteArrayAsync(url);
string rJson = Encoding.UTF8.GetString(rData);
//Logger.Debug("应答：\r\n{0}", rJson);
response = Newtonsoft.Json.JsonConvert.DeserializeObject <TResponse>(rJson);
}
catch (System.Exception e)
{
TResponse r = new TResponse();
//Logger.Error("请求异常：\r\n{0}", e.ToString());
return(r);
}
return(response);
}
private async void parsing(string Url)
{
try
{
chargement.Visibility = Visibility.Visible;
HttpClient http = new System.Net.Http.HttpClient();
var reponse = await http.GetByteArrayAsync(Url);
String str = System.Text.Encoding.GetEncoding("UTF-8").GetString(reponse, 0, reponse.Length - 1);
var strdecode = System.Net.WebUtility.HtmlDecode(str);
HtmlDocument htmldoc = new HtmlDocument();
htmldoc.LoadHtml(strdecode);
var l0 = htmldoc.DocumentNode.Descendants("img").Where(x => (x.Attributes.Contains("class") && String.Equals((String)x.GetAttributeValue("class", "null"), "uk-border-rounded"))).ToList();
var l1 = htmldoc.DocumentNode.Descendants("p").ToList();
var l2 = htmldoc.DocumentNode.Descendants("h2").ToList();
int i = 0;
while (i < 10)
{
LList.Add(new ImageModel
{
lien = "http://simplereminders.com/domains/simplereminders.com" + l0[i].GetAttributeValue("src", null).ToString(),
//Quote = l1[i].InnerText.ToString(),
//Post = l2[i-1].InnerText.ToString()
});
i++;
}
ImageGrid.DataContext = LList;
chargement.Visibility = Visibility.Collapsed;
}
catch
{
MessageDialog mesg = new MessageDialog("Please verify your Internet connection");
mesg.ShowAsync();
}
}
public Task <byte[]> GetByteArrayAsync(string requestUri)
{
return(_builtInHttpClient.GetByteArrayAsync(requestUri));
}
public Task <byte[]> GetByteArrayAsync(string requestUri)
{
return(_inner.GetByteArrayAsync(requestUri));
}
/// <summary>
/// Asynchronously downloads a file as a byte array from the specified URL.
/// </summary>
public Task <byte[]> DownloadAsync(string url)
{
return(_client.GetByteArrayAsync(url));
}
void BindRTB(HttpResponseMessage response, int fileorfolder)
{
if (!response.IsSuccessStatusCode)
{
Message = "The GitHub Module Name/Path provided is invalid. Error :" + response.ReasonPhrase + ".";
Console.WriteLine("The GitHub Module Name/Path provided is invalid. Error :" + response.ReasonPhrase + ".");
}
else
{
var dataObjects = response.Content.ReadAsStringAsync();
dynamic srcData = Json.Decode(dataObjects.Result);
if (fileorfolder == 0)
{
foreach (var item in srcData)
{
string itemext = string.Empty;
int index = item.name.IndexOf(".");
if (index == -1)
{
}
else
{
itemext = item.name.Substring(index);
}
if (!ExtList.Contains(itemext) || string.IsNullOrEmpty(itemext))
{
//do nothing
}
else
{
foreach (var item1 in ExcludeFiles)
{
if (item.name == item1)
{
flag = true;
Message = "Successful Message : File:" + item.name + " : has been successfully excluded.";
Console.WriteLine("Successful Message : File:" + item.name + " : has been successfully excluded.");
break;
}
else
{
flag = false;
}
}
if (!flag)
{
try
{
string Filepath = ModulePath + "\\" + item.name;
using (var client = new System.Net.Http.HttpClient())
{
var credentials = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}:", sToken);
credentials = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(credentials));
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", credentials);
var contents = client.GetByteArrayAsync(item.download_url).Result;
System.IO.File.WriteAllBytes(Filepath, contents);
}
Message = "Successful Message : File:" + item.name + " : has been successfully downloaded.";
Console.WriteLine("Successful Message : File:" + item.name + " : has been successfully downloaded.");
}
catch (System.Exception e)
{
Message = "Error while getting the File:" + item.name + "(" + e.Message + ")";
Console.WriteLine(Message);
FileErr = true;
}
}
flag = false;
}
}
}
else
{
//Do nothing;
}
}
}
public async Task <byte[]> GetByteArrayAsync(string uri) => await _Client.GetByteArrayAsync(uri);
/// <summary>
/// Send a GET request to the specified Uri and return the response body as a byte array in a synchronous operation.
/// </summary>
/// <param name="requestUri">The Uri the request is sent to.</param>
/// <exception cref="ArgumentNullException">
/// The <paramref name="requestUri"/> was null.
/// </exception>
public static byte[] GetByteArray(this HttpClient client, Uri requestUri)
{
return(Task.Run(() => client.GetByteArrayAsync(requestUri)).Result);
}
static async Task Main(string[] args)
{
var app = new CommandLineApplication();
app.HelpOption("-h|--help");
var optionUrl = app.Option("-u|--url <URL>", "The server url to request", CommandOptionType.SingleValue).IsRequired();
var optionConnections = app.Option <int>("-c|--connections <N>", "Total number of HTTP connections to open. Default is 10.", CommandOptionType.SingleValue);
var optionWarmup = app.Option <int>("-w|--warmup <N>", "Duration of the warmup in seconds. Default is 5.", CommandOptionType.SingleValue);
var optionDuration = app.Option <int>("-d|--duration <N>", "Duration of the test in seconds. Default is 5.", CommandOptionType.SingleValue);
var optionHeaders = app.Option("-H|--header <HEADER>", "HTTP header to add to request, e.g. \"User-Agent: edge\"", CommandOptionType.MultipleValue);
var optionVersion = app.Option("-v|--version <1.0,1.1,2.0>", "HTTP version, e.g. \"2.0\". Default is 1.1", CommandOptionType.SingleValue);
var optionCertPath = app.Option("-t|--cert <filepath>", "The path to a cert pfx file.", CommandOptionType.SingleValue);
var optionCertPwd = app.Option("-p|--certpwd <password>", "The password for the cert pfx file.", CommandOptionType.SingleValue);
app.OnExecuteAsync(async cancellationToken =>
{
Console.WriteLine("Http Client");
Console.WriteLine($"args: {string.Join(" ", args)}");
ServerUrl = optionUrl.Value();
WarmupTimeSeconds = optionWarmup.HasValue()
? int.Parse(optionWarmup.Value())
: 5;
ExecutionTimeSeconds = optionDuration.HasValue()
? int.Parse(optionDuration.Value())
: 5;
Connections = optionConnections.HasValue()
? int.Parse(optionConnections.Value())
: 10;
Headers = new List <string>(optionHeaders.Values);
if (!optionVersion.HasValue())
{
Version = HttpVersion.Version11;
}
else
{
switch (optionVersion.Value())
{
case "1.0": Version = HttpVersion.Version10; break;
case "1.1": Version = HttpVersion.Version11; break;
case "2.0": Version = HttpVersion.Version20; break;
default:
Console.WriteLine("Unkown HTTP version: {0}", optionVersion.Value());
break;
}
}
if (optionCertPath.HasValue())
{
CertPath = optionCertPath.Value();
Console.WriteLine("CerPath: " + CertPath);
CertPassword = optionCertPwd.Value();
if (CertPath.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine($"Downloading cert from: {CertPath}");
var httpClientHandler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator,
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
};
var httpClient = new System.Net.Http.HttpClient(httpClientHandler);
var bytes = await httpClient.GetByteArrayAsync(CertPath);
Certificate = new X509Certificate2(bytes, CertPassword);
Console.WriteLine("Cert Thumb: " + Certificate.Thumbprint);
}
else
{
Console.WriteLine($"Using cert from: {CertPath}");
Certificate = new X509Certificate2(CertPath, CertPassword);
}
}
await RunAsync();
});
await app.ExecuteAsync(args);
}
///// <summary>
///// Basic認証用
///// </summary>
//public RawlerLib.BasicAuthorization BasicAuthorization { get; set; }
/// <summary>
/// HttpGet
/// </summary>
/// <param name="url"></param>
/// <param name="enc"></param>
/// <returns></returns>
public virtual async Task <string> HttpGet(string url, Encoding enc = null, string referer = default(string))
{
await Sleep();
if (UseCache)
{
var h = GetCashe(url);
if (h != null)
{
return(h);
}
}
ErrMessage = string.Empty;
string result = string.Empty;
bool retry = false;
if (ReportUrl)
{
ReportManage.Report(this, "GET " + url, true, true);
}
try
{
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient(handler, false);
client.DefaultRequestHeaders.UserAgent.ParseAdd(this.UserAgent);
client.DefaultRequestHeaders.Referrer = new Uri(referer);
var data = await client.GetByteArrayAsync(url);
if (enc != null)
{
result = enc.GetString(data, 0, data.Length);
}
else
{
result = GetAutoEncoding(data, out encoder);
}
}
catch (Exception e)
{
if (visbleErr)
{
ReportManage.ErrReport(this, "Url:" + url + " " + e.Message);
}
ErrMessage = e.Message;
retry = false;
}
if (retry)
{
count++;
if (count <= tryCount)
{
ReportManage.ErrReport(this, "HttpGet:" + url + "にリトライ待機中");
await Task.Delay(new TimeSpan(0, 0, 10 * count * count));
result = await this.HttpGet(url, enc);
}
else
{
ReportManage.ErrReport(this, "HttpGet:" + url + "に失敗しました");
result = string.Empty;
}
}
if (UseCache)
{
casheDic.GetValueOrAdd(url, new WeakReference <string>(result));
}
return(result);
}
private async void GetDividents()
{
HttpClient client = new HttpClient();
var response = await client.GetByteArrayAsync(this.DIVIDENTSURL);
string source = Encoding.GetEncoding("utf-8").GetString(response, 0, response.Length - 1);
source = WebUtility.HtmlDecode(source);
HtmlAgilityPack.HtmlDocument result = new HtmlAgilityPack.HtmlDocument();
result.LoadHtml(source);
List<HtmlNode> required = result.DocumentNode.Descendants().Where(x => (x.Name == "table" && x.Attributes["class"] != null && x.Attributes["class"].Value.Contains("exdiv"))).ToList();
var tr = required[0].Descendants("tr").Where(x => (x.Name == "tr" && x.Attributes["class"] != null && x.Attributes["class"].Value.Contains("yield"))).ToList();
if (tr.Any())
{
foreach (var item in tr)
{
var test = item.Descendants("td").ToList();
string name = test[0].InnerText.Trim();
string exDiv = test[3].InnerText.Trim();
string payDate = test[4].InnerText.Trim();
string payout = test[5].InnerText.Trim();
string price = test[7].InnerText.Trim();
string yield = test[8].InnerText.Trim();
int rowId = this.dataGridDividents.Rows.Add();
this.dataGridDividents.Rows[rowId].Cells[0].Value = name;
this.dataGridDividents.Rows[rowId].Cells[1].Value = exDiv;
this.dataGridDividents.Rows[rowId].Cells[2].Value = payDate;
this.dataGridDividents.Rows[rowId].Cells[3].Value = payout;
this.dataGridDividents.Rows[rowId].Cells[4].Value = price;
this.dataGridDividents.Rows[rowId].Cells[5].Value = yield;
}
}
}