selenium codes

1) Installation
Open visual studio, go to Tools -> Nuget Package Manager -> Console and insert

Code:

Install-Package Selenium.WebDriver

2) Basics
Profiles: they define the preferences, as the use of a proxy or an user agent or even the volume

Code:

var profile = new FirefoxProfile();
profile.SetPreference("network.proxy.type", 1);
profile.SetPreference("network.proxy.http", ip);
profile.SetPreference("network.proxy.http_port", port);
profile.SetPreference("general.useragent.override", "ebin useragent");
profile.SetPreference("media.volume_scale", "0.0");

IWebDriver: the driver is the browser module that we are using so for example

Code:

IWebDriver driver = new FirefoxDriver(profile);
driver.Navigate().GoToUrl("http://website.com");

IWebElement: it is an element of the dom page you can use as a node, example

Code:

IWebElement e = w.FindElement(By.Id("mydiv"));

3) Navigation through nodes
Selenium can find an element or multiple elements on the page by many things, IDs, classnames, names, tags, etc...but you will get an exception if this element is not there already! Suppose you have a page which makes a redirect, you will need to wait for that element to show up in order to get it so we have to implement a basic listener

Code:

bool exc = true;
while (exc)
{
   try
     {
        IWebElement e = driver.FindElement(By.Id("mydiv"));
        exc = false;
        //ETC.....
     }
      catch (NoSuchElementException) { }
}

This does not apply to collections, each IWebElement can be used as a node to search elements inside.
If you want to wait in general you can use

Code:

driver.Manage().Timeouts().ImplicitlyWait(timeSpan);

You can even access the page source through driver.PageSource

4)Fulfilling form data and windows
You can easily input form data by using SendKeys() and Submit() methods

Code:

driver.FindElement(By.Id("username")).SendKeys(username);
driver.FindElement(By.Id("password")).SendKeys(password);
driver.FindElement(By.Id("login_form")).Submit();

Even if I suggest to just use .Click() on the submit button due to internal delays

To handle the focus and the windows of the browser you can use the SwitchTo() method which returns an ITargetLocator. For example you can set it to an iframe with .Frame() or to another window with .Window(). Examples:

Code:

//goes to first window
driver.SwitchTo().Window(driver.WindowHandles[0]);
//accepts alert
driver.SwitchTo().Alert().Accept();

To get the current window you can use driver.CurrentWindowHandle and for all driver.WindowHandles

5)Other features
Of course, we can execute javascript as well! By using IJavaScriptExecutor

Code:

(driver as IJavaScriptExecutor).ExecuteScript("alert(1);alert(2);alert(3);");

Or handle cookies

Code:

driver.Manage().Cookies.AddCookie(new Cookie("lol","hello","/","domain.com",new DateTime(2020,10,20)));
var cookies = driver.Manage().Cookies.AllCookies;
driver.Manage().Cookies.DeleteAllCookies();

And last but not least, you can even take screenshots with ITakesScreenshot!

Code:

(driver as ITakesScreenshot).GetScreenshot().SaveAsFile("lol.png",System.Drawing.Imaging.ImageFormat.Png);

If you need to hide the whole process you can just use ShowWindow with SW_HIDE

Code:

[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, uint nCmdShow);
//...
ShowWindow(Process.GetProcessesByName("firefox")[0].MainWindowHandle, 0);

I put effort on this I really hope you appreciate!

C# webbrowser1 clear cookie

dynamic document = webBrowser1.Document;
document.ExecCommand("ClearAuthenticationCache", false, null);

c# ReadTextFileAsync. txt okuma

ReadTextFileAsync.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;

public class ReadTextFileAsync
{
    static void Main()
    {    
        Task task = new Task(ReadMyFile);
        task.Start();
        
        Console.ReadLine();
    }
    
    static async void ReadMyFile() {
    
        FileStream fs = new FileStream("thermopylae.txt", 
                FileMode.Open, FileAccess.Read);
        
        using (StreamReader reader = new StreamReader(fs, Encoding.UTF8))
        {
            string text = await reader.ReadToEndAsync();
            Console.WriteLine(text);
        }    
    }
}

In the next example, we read a text file asynchronously.

Task task = new Task(ReadMyFile);
task.Start();

A Task class represents an asynchronous operation.

string text = await reader.ReadToEndAsync();

c# selenium multiple tabs

Selenium multiple tabs:

driver = new ChromeDriver();
IJavaScriptExecutor jscript = driver as IJavaScriptExecutor;
for (int i = 0; i < 10; i++)
{                
  driver.Navigate().GoToUrl(this.baseURL);      
  jscript.ExecuteScript("window.open('{0}', '_blank');", this.baseURL);
}

Swich between them:

for (int i = 0; i < driver.WindowHandles.Count; i++)
{ 
  driver.SwitchTo().Window(driver.WindowHandles[i])]);
}

c# WebBrowser control

I need to embed HTML in my applications. If it is just to display some simple layout with basic interactions, I might use a component such as HtmlRenderer. In most cases however, I need a more complex layout, JavaScript or I might want to display real pages from the internet - in which case I'm lumbered with the WebBrowser control.

I'm aware other embeddable browsers exist, but the idea of shipping additional multi-MB dependencies doesn't make sense unless an application makes heavy use of HTML interfaces

The WebBrowser control annoys me in myriad ways, but it does get the job done. One of the things that occasionally frustrates me is that by default it is essentially an embedded version of Internet Explorer 7 - or enabling Compatibility Mode in a modern IE session. Not so good as more and more sites use HTML5 and other goodies.

Rather fortunately however, Microsoft provide the ability to configure the emulation mode your application will use. It's not as simple as setting some properties on a control as it involves setting some registry values and other caveats, but it is still a reasonable process.

About browser emulation versions

The table below (source) lists the currently supported emulation versions at the time of writing. As you can see, it's possible to emulate all "recent" versions of Internet Explorer in one of two ways - either by forcing a standards mode, or allowing !DOCTYPE directives to control the mode. The exception to this dual behaviour is version 7 which is as is.

According to the documentation the IE8 (8000) and IE9 (9000) modes will switch to IE10 (10000) mode if installed. The documentation doesn't mention if this is still the case regarding IE11 so I'm not sure on the behaviour in that regard.

Value	Description
11001	Internet Explorer 11. Webpages are displayed in IE11 edge mode, regardless of the !DOCTYPE directive.
11000	IE11. Webpages containing standards-based !DOCTYPE directives are displayed in IE11 edge mode. Default value for IE11.
10001	Internet Explorer 10. Webpages are displayed in IE10 Standards mode, regardless of the !DOCTYPE directive.
10000	Internet Explorer 10. Webpages containing standards-based !DOCTYPE directives are displayed in IE10 Standards mode. Default value for Internet Explorer 10.
9999	Windows Internet Explorer 9. Webpages are displayed in IE9 Standards mode, regardless of the !DOCTYPE directive.
9000	Internet Explorer 9. Webpages containing standards-based !DOCTYPE directives are displayed in IE9 mode. Default value for Internet Explorer 9.
8888	Webpages are displayed in IE8 Standards mode, regardless of the !DOCTYPE directive.
8000	Webpages containing standards-based !DOCTYPE directives are displayed in IE8 mode. Default value for Internet Explorer 8
7000	Webpages containing standards-based !DOCTYPE directives are displayed in IE7 Standards mode. Default value for applications hosting the WebBrowser Control.

Setting the browser emulation version

Setting the emulation version is very straightforward - add a value to the registry in the below key containing the name of your executable file and a value from the table above.

HKEY_LOCAL_MACHINE (or HKEY_CURRENT_USER)
   SOFTWARE
      Microsoft
         Internet Explorer
            Main
               FeatureControl
                  FEATURE_BROWSER_EMULATION
                     yourapp.exe = (DWORD) version

Note: If you do this from an application you're debugging using Visual Studio and the Visual Studio Hosting Process option is enabled you'll find the executable name may not be what you expect. When enabled, a stub process with a slightly modified name is used instead. For example, if your application is named calc.exe, you'll need to add the value calc.vshost.exe in order to set the emulated version for the correct process.

Getting the Internet Explorer version

As it makes more sense to detect the version of IE installed on the user's computer and set the emulation version to match, first we need a way of detecting the IE version.

There are various ways of getting the installed IE version, but the sensible method is reading the value from the registry as everything else we are doing in this article involves the registry in some fashion.

HKEY_LOCAL_MACHINE
   SOFTWARE
      Microsoft
         Internet Explorer
            svcVersion or Version

Older versions of IE used the Version value, while newer versions use svcVersion. In either case, this value contains the version string.

We can use the following version to pull out the major digit.

private const string InternetExplorerRootKey = @"Software\Microsoft\Internet Explorer";

public static int GetInternetExplorerMajorVersion()
{
  int result;

  result = 0;

  try
  {
    RegistryKey key;

    key = Registry.LocalMachine.OpenSubKey(InternetExplorerRootKey);

    if (key != null)
    {
      object value;

      value = key.GetValue("svcVersion", null) ?? key.GetValue("Version", null);

      if (value != null)
      {
        string version;
        int separator;

        version = value.ToString();
        separator = version.IndexOf('.');
        if (separator != -1)
        {
          int.TryParse(version.Substring(0, separator), out result);
        }
      }
    }
  }
  catch (SecurityException)
  {
    // The user does not have the permissions required to read from the registry key.
  }
  catch (UnauthorizedAccessException)
  {
    // The user does not have the necessary registry rights.
  }

  return result;
}

Points to note:

• I'm returning an int with the major version component rather a Version class. In this example, I don't need a full version to start with and it avoids crashes if the version string is invalid
• For the same reason, I'm explicitly catching (and ignoring) SecurityException and UnauthorizedAccessException exceptions which will be thrown if the user doesn't have permission to access those keys. Again, I don't really want the function crashing for those reasons.

You can always remove the try block to have all exceptions thrown instead of the access exceptions being ignored.

Getting the browser emulation version

The functions to get and set the emulation version are using HKEY_CURRENT_USER to make them per user rather than for the entire machine.

First we'll create an enumeration to handle the different versions described above so that we don't have to deal with magic numbers.

public enum BrowserEmulationVersion
{
  Default = 0,
  Version7 = 7000,
  Version8 = 8000,
  Version8Standards = 8888,
  Version9 = 9000,
  Version9Standards = 9999,
  Version10 = 10000,
  Version10Standards = 10001,
  Version11 = 11000,
  Version11Edge = 11001
}

Next, a function to detect the current emulation version in use by our application, and another to quickly tell if an emulation version has previously been set.

private const string BrowserEmulationKey = InternetExplorerRootKey + @"\Main\FeatureControl\FEATURE_BROWSER_EMULATION";

public static BrowserEmulationVersion GetBrowserEmulationVersion()
{
  BrowserEmulationVersion result;

  result = BrowserEmulationVersion.Default;

  try
  {
    RegistryKey key;

    key = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, true);
    if (key != null)
    {
      string programName;
      object value;

      programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
      value = key.GetValue(programName, null);

      if (value != null)
      {
        result = (BrowserEmulationVersion)Convert.ToInt32(value);
      }
    }
  }
  catch (SecurityException)
  {
    // The user does not have the permissions required to read from the registry key.
  }
  catch (UnauthorizedAccessException)
  {
    // The user does not have the necessary registry rights.
  }

  return result;
}

public static bool IsBrowserEmulationSet()
{
  return GetBrowserEmulationVersion() != BrowserEmulationVersion.Default;
}

Setting the emulation version

And finally, we need to be able to set the emulation version. I've provided two functions for doing this, one which allows you to explicitly set a value, and another that uses the best matching value for the installed version of Internet Explorer.

public static bool SetBrowserEmulationVersion(BrowserEmulationVersion browserEmulationVersion)
{
  bool result;

  result = false;

  try
  {
    RegistryKey key;

    key = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, true);

    if (key != null)
    {
      string programName;

      programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);

      if (browserEmulationVersion != BrowserEmulationVersion.Default)
      {
        // if it's a valid value, update or create the value
        key.SetValue(programName, (int)browserEmulationVersion, RegistryValueKind.DWord);
      }
      else
      {
        // otherwise, remove the existing value
        key.DeleteValue(programName, false);
      }

      result = true;
    }
  }
  catch (SecurityException)
  {
    // The user does not have the permissions required to read from the registry key.
  }
  catch (UnauthorizedAccessException)
  {
    // The user does not have the necessary registry rights.
  }

  return result;
}

public static bool SetBrowserEmulationVersion()
{
  int ieVersion;
  BrowserEmulationVersion emulationCode;

  ieVersion = GetInternetExplorerMajorVersion();

  if (ieVersion >= 11)
  {
    emulationCode = BrowserEmulationVersion.Version11;
  }
  else
  {
    switch (ieVersion)
    {
      case 10:
        emulationCode = BrowserEmulationVersion.Version10;
        break;
      case 9:
        emulationCode = BrowserEmulationVersion.Version9;
        break;
      case 8:
        emulationCode = BrowserEmulationVersion.Version8;
        break;
      default:
        emulationCode = BrowserEmulationVersion.Version7;
        break;
    }
  }

  return SetBrowserEmulationVersion(emulationCode);
}

As mentioned previously, I don't really want these functions crashing for anticipated reasons, so these functions will also catch and ignore SecurityException and UnauthorizedAccessException exceptions. The SetBrowserEmulationVersion function will return true if a value was updated.

Simple Usage

If you just want "fire and forget" updating of the browser emulation version, you can use the following lines.

if (!InternetExplorerBrowserEmulation.IsBrowserEmulationSet())
{
  InternetExplorerBrowserEmulation.SetBrowserEmulationVersion();
}

This will apply the best matching IE version if an emulation version isn't set. However, it means if the user updates their copy if IE to something newer, your application will potentially continue to use the older version. I shall leave that as an exercise for another day!

Caveats and points to note

Changing the emulation version while your application is running

While experimenting with this code, I did hit a major caveat.

In the original application this code was written for, I was applying the emulation version just before the first window containing a WebBrowser control was loaded, and this worked perfectly well.

However, setting the emulation version doesn't seem to work if an instance of the WebBrowser control has already been created in your application. I tried various things such as recreating the WebBrowser control or reloading the Form the control was hosted on, but couldn't get the new instance to honour the setting without an application restart.

The attached demonstration program has gone with the "restart after making a selection" hack - please don't do this in production applications!

Should I change the emulation version of my application?

You should carefully consider where or not to change the emulation version of your application. If it's currently working fine, then it's probably better to leave it as is. If however, you wish to make use of modern standards compliant HTML, CSS or JavaScript then setting the appropriate emulation version will save you a lot of trouble.

Further Reading

The are a lot of different options you can apply to Internet Explorer and the WebBrowser control. These options allow you to change behaviours, supported features and quite a few more. This article has touched upon one of the more common requirements, but there are a number of other options that are worth looking at for advanced application scenarios.

An index of all available configuration options can be found on MSDN.

Source

c# add watermark image

   private void button1_Click(object sender, EventArgs e)
    {
        using (Image image = Image.FromFile(@"C:\Users\Public\Pictures\Sample Pictures\Desert.jpg"))
        using (Image watermarkImage = Image.FromFile(@"C:\Users\Public\Pictures\Sample Pictures\watermark.png"))
        using (Graphics imageGraphics = Graphics.FromImage(image))
        using (TextureBrush watermarkBrush = new TextureBrush(watermarkImage))
        {
            int x = (image.Width / 2 - watermarkImage.Width / 2);
            int y = (image.Height / 2 - watermarkImage.Height / 2);
            watermarkBrush.TranslateTransform(x, y);
            imageGraphics.FillRectangle(watermarkBrush, new Rectangle(new Point(x, y), new Size(watermarkImage.Width+1, watermarkImage.Height)));
            image.Save(@"C:\Users\Public\Pictures\Sample Pictures\Desert_watermark.jpg");
        }

    }