सेलेनियम c # वेबड्राइवर: तत्व मौजूद होने तक प्रतीक्षा करें

Question

मैं यह सुनिश्चित करना चाहता हूं कि वेबड्राइवर सामान करने से पहले एक तत्व मौजूद हो।

मैं काम करने के लिए कुछ इस तरह की कोशिश कर रहा हूँ:

WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0,0,5));
wait.Until(By.Id("login"));

मैं मुख्य रूप से संघर्ष कर रहा हूँ कि कैसे जन्नत समारोह की स्थापना की जाए ..

Comments

FYI करें - यह आपके टाइमपेन को इस तरह बनाने के लिए क्लीनर है TimeSpan.FromSeconds(5)। यह अधिक स्पष्ट IMO बनाता है

— Kolob Canyon

Answer 1

वैकल्पिक रूप से आप अंतर्निहित प्रतीक्षा का उपयोग कर सकते हैं:

driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);

एक निहित प्रतीक्षा के लिए WebDriver को यह बताना है कि जब वे तत्काल उपलब्ध नहीं हैं तो किसी तत्व या तत्वों को खोजने की कोशिश करने पर DOM को एक निश्चित समय के लिए प्रदूषित कर सकते हैं। डिफ़ॉल्ट सेटिंग 0. है। एक बार सेट करने के बाद, अंतर्निहित प्रतीक्षा वेबड्राइवर ऑब्जेक्ट इंस्टेंस के जीवन के लिए सेट है।

Comments

धन्यवाद, नया वाक्यविन्यास है: driver.manage ()। टाइमआउट ()। निहितार्थ (10, TimeUnit.SECONDS);

— Reda

@RedaBalkouch, उनके उत्तर में प्रयुक्त वाक्यविन्यास माइक सही है। यह C #

— Diemo

यदि आप अंतर्निहित प्रतीक्षा का उपयोग करना चुनते हैं, तो सावधान रहें कि स्पष्ट प्रतीक्षा का उपयोग न करें। यह कुछ अप्रत्याशित व्यवहार का कारण बन सकता है जिससे खराब परीक्षा परिणाम हो सकते हैं। आम तौर पर बोलना, मैं अंतर्निहित प्रतीक्षा से अधिक स्पष्ट प्रतीक्षा का उपयोग करने की सलाह दूंगा।

— mrfreester

यह विधि अब पदावनत हो गई है, आपको इसके बजाय संपत्ति का उपयोग करना चाहिए ImplicitWait:Driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);

— सैमुअल रोंडेउ-मिलियरे

मैंने प्रदान किए गए दृष्टिकोण का उपयोग किया और पाया कि विधि को शमूएल द्वारा बताया गया था। एक आइटम के अस्तित्व के लिए जाँच अब निर्दिष्ट समय तक इंतजार कर रहा है।

— जिम स्कॉट

Answer 2

माइक कवन द्वारा प्रदान किए गए समाधान का उपयोग करने से समग्र परीक्षण प्रदर्शन पर प्रभाव पड़ सकता है, क्योंकि निहित प्रतीक्षा का उपयोग सभी FindElement कॉल में किया जाएगा। कई बार आप चाहते हैं कि कोई तत्व मौजूद न होने पर आप तुरंत FindElement को विफल कर दें (आप किसी विकृत पृष्ठ के लिए परीक्षण कर रहे हैं, लापता तत्व, आदि)। निहित प्रतीक्षा के साथ ये ऑपरेशन अपवाद को फेंकने से पहले पूरे समय समाप्त होने की प्रतीक्षा करेंगे। डिफ़ॉल्ट निहित प्रतीक्षा 0 सेकंड के लिए सेट है।

मैंने IWebDriver के लिए थोड़ा विस्तार विधि लिखी है जो विधि में एक टाइमआउट (सेकंड में) पैरामीटर जोड़ता है FindElement()। यह काफी आत्म-व्याख्यात्मक है:

public static class WebDriverExtensions
{
    public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => drv.FindElement(by));
        }
        return driver.FindElement(by);
    }
}

मैंने WebDriverWait ऑब्जेक्ट को कैश नहीं किया क्योंकि इसका निर्माण बहुत सस्ता है, इस एक्सटेंशन का उपयोग अलग-अलग WebDriver ऑब्जेक्ट्स के लिए एक साथ किया जा सकता है, और मैं केवल तब अनुकूलन करता हूं जब अंततः आवश्यकता होती है।

उपयोग सीधे-आगे है:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost/mypage");
var btn = driver.FindElement(By.CssSelector("#login_button"));
btn.Click();
var employeeLabel = driver.FindElement(By.CssSelector("#VCC_VSL"), 10);
Assert.AreEqual("Employee", employeeLabel.Text);
driver.Close();

Comments

मामले में किसी को आश्चर्य में, WebDriverWaitसे हैं OpenQA.Selenium.Support.UIनाम स्थान और कहा जाता है एक अलग पैकेज में आता है Selenium WebDriver Support ClassesNuGet पर

— एंडी

डी: @Ved मैं तुम्हें <3 एक अलग dll में इसके लिए तलाश कर दिया गया चुंबन सकता है

— Adween

@ लॉडनवीयर कृपया पहली पंक्ति को बोल्ड करें ताकि यह अधिक ध्यान देने योग्य हो। खासकर जब से यह स्वीकृत उत्तर नहीं है, हालांकि एक बेहतर और सटीक दृष्टिकोण है।

— रिक

Selenium WebDriver Support Classesअब NuGet पर "सेलेनियम.सुपोर्ट" के रूप में दिखाई देता है , वर्तमान संस्करण 3.4.0 है

— एरिक एफ।

जब तक मैंने इस लाइन का उपयोग नहीं किया तब तक मेरे पास बहुत सारी त्रुटियां थीं return wait.Until(ExpectedConditions.ElementToBeClickable(by));और यह अब बहुत अच्छा काम करती है। मामले में किसी और को यादृच्छिक तत्वों को अभी भी नहीं मिला है।

— पूर्वेक्षक

Answer 3

आप भी उपयोग कर सकते हैं

ExpectedConditions.ElementExists

तो आप इस तरह एक तत्व उपलब्धता के लिए खोज करेंगे

new WebDriverWait(driver, TimeSpan.FromSeconds(timeOut)).Until(ExpectedConditions.ElementExists((By.Id(login))));

स्रोत

Comments

सहमत, यह एक मात्र टाइमआउट की तुलना में कहीं अधिक उपयोगी है (उन मामलों में जहां आप गतिशील रूप से किसी वस्तु को लोड कर रहे हैं)।

— कीथल ke०४१

जबकि यह काम करता है। अब इसे पदावनत के रूप में चिह्नित किया जाता है, इसलिए इससे बचना चाहिए।

— एडम गार्नर

यहाँ नया दृष्टिकोण (पदावनत नहीं): stackoverflow.com/a/49867605/331281

— देजन

ध्यान दें, इस समय, DotNetSeleniumExtras.WaitHelpers(ऊपर @Dejan द्वारा संदर्भित) "बनाए रखा नहीं जाता है, मुद्दे तय नहीं किए जाएंगे, पीआर स्वीकार नहीं किए जाएंगे"। (स्रोत: github.com/SeleniumHQ/selenium/issues/… )। इसके प्रकाशक इसे अपने ऊपर से लेने के लिए एक अनुचर की मांग कर रहे हैं।

— 13

Answer 4

यहाँ @ Loudenvier के समाधान की विविधता है जो कई तत्वों को प्राप्त करने के लिए भी काम करता है:

public static class WebDriverExtensions
{
    public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => drv.FindElement(by));
        }
        return driver.FindElement(by);
    }

    public static ReadOnlyCollection<IWebElement> FindElements(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => (drv.FindElements(by).Count > 0) ? drv.FindElements(by) : null);
        }
        return driver.FindElements(by);
    }
}

Comments

अच्छा! मैंने इसे केवल अपनी लाइब्रेरी में जोड़ा है! यह कोड साझा करने की सुंदरता है !!!

— ०१:०१ पर लाउडेनवियर

मैं इसके अलावा एक सुझाव देना चाहूंगा। आप NoSuchElement के समाधान को पकड़ सकते हैं और उस उदाहरण में अशक्त हो सकते हैं। तब आप .exists नाम की एक एक्सटेंशन विधि बना सकते हैं, जब तक कि IWebElement शून्य न हो जाए।

— ब्रेंटली ब्लैंचर्ड

Answer 5

लाउडेनवियर के समाधान से प्रेरित, यहां एक विस्तार विधि है जो सभी ISearchContext ऑब्जेक्ट्स के लिए काम करती है, न कि केवल IWebDriver, जो कि पूर्व की विशेषज्ञता है। यह विधि तत्व प्रदर्शित होने तक प्रतीक्षा का भी समर्थन करती है।

static class WebDriverExtensions
{
    /// <summary>
    /// Find an element, waiting until a timeout is reached if necessary.
    /// </summary>
    /// <param name="context">The search context.</param>
    /// <param name="by">Method to find elements.</param>
    /// <param name="timeout">How many seconds to wait.</param>
    /// <param name="displayed">Require the element to be displayed?</param>
    /// <returns>The found element.</returns>
    public static IWebElement FindElement(this ISearchContext context, By by, uint timeout, bool displayed=false)
    {
        var wait = new DefaultWait<ISearchContext>(context);
        wait.Timeout = TimeSpan.FromSeconds(timeout);
        wait.IgnoreExceptionTypes(typeof(NoSuchElementException));
        return wait.Until(ctx => {
            var elem = ctx.FindElement(by);
            if (displayed && !elem.Displayed)
                return null;

            return elem;
        });
    }
}

उदाहरण उपयोग:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost");
var main = driver.FindElement(By.Id("main"));
var btn = main.FindElement(By.Id("button"));
btn.Click();
var dialog = main.FindElement(By.Id("dialog"), 5, displayed: true);
Assert.AreEqual("My Dialog", dialog.Text);
driver.Close();

Comments

यदि आपने एक अंतर्निहित प्रतीक्षा सेट की है, तो यह आपके द्वारा यहां निर्धारित _webDriver.Manage().Timeouts().ImplicitlyWait(Timeout);टाइमआउट मूल्य को अभी भी ट्रम्प करेगा।

— Howcheng

यह मेरे लिए काम नहीं लगता ...? मैंने Stopwatchकॉल को एक्सटेंशन विधि और Console.WriteLine()लैंबडा के अंदर भेजा Until()। स्टॉपवॉच को लगभग 60 सेकंड मापा गया और केवल एक संदेश लिखा गया था Console। क्या मुझसे कोई चूक हो रही है?

— उरग

Answer 6

मैंने किसी भी प्रकार की क्रिया को विधेय के साथ भ्रमित किया। एक छोटी सहायक विधि है:

   WebDriverWait wait;
    private void waitForById(string id) 
    {
        if (wait == null)            
            wait = new WebDriverWait(driver, new TimeSpan(0,0,5));

        //wait.Until(driver);
        wait.Until(d => d.FindElement(By.Id(id)));
    }

Answer 7

आप C # में कुछ इस तरह का पता लगा सकते हैं।

यह वही है जो मैंने JUnit - सेलेनियम में उपयोग किया था

WebDriverWait wait = new WebDriverWait(driver, 100);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("submit")));

संबंधित पैकेज आयात करें

Comments

मैं और यह आज के उपयोग का प्रयास VS.net मुझे चेतावनी दे रहा है: OpenQA.Selenium.Support.UI.ExpectedConditions वर्ग में चिन्हित किया "पदावनत" किया है और पर रेपो "DotNetSeleniumExtras के लिए चले" था github.com/DotNetSeleniumTools

— जेफ Mergler

Answer 8

//wait up to 5 seconds with no minimum for a UI element to be found
WebDriverWait wait = new WebDriverWait(_pagedriver, TimeSpan.FromSeconds(5));
IWebElement title = wait.Until<IWebElement>((d) =>
{
    return d.FindElement(By.ClassName("MainContentHeader"));
});

Answer 9

public bool doesWebElementExist(string linkexist)
{
     try
     {
        driver.FindElement(By.XPath(linkexist));
        return true;
     }
     catch (NoSuchElementException e)
     {
        return false;
     }
}

Comments

उपरोक्त कोड यह जांचने के लिए है कि कोई विशेष तत्व मौजूद है या नहीं।

— मधु

Answer 10

जब आप सेलेनियम आईडीई में वेबड्राइवर प्रारूप चुनते हैं, तो क्लिकअंडविट कमांड परिवर्तित नहीं होती है। यहाँ वर्कअराउंड है। नीचे प्रतीक्षा रेखा जोड़ें। वास्तविक रूप से, समस्या क्लिक या ईवेंट थी जो मेरे C # कोड में इस एक - लाइन 1 से पहले हुई थी। लेकिन वास्तव में, सुनिश्चित करें कि आपके पास किसी भी कार्रवाई से पहले एक WaitForElement है जहां आप "द्वारा" ऑब्जेक्ट का संदर्भ दे रहे हैं।

HTML कोड:

<a href="http://www.google.com">xxxxx</a>

C # / NUnit कोड:

driver.FindElement(By.LinkText("z")).Click;
driver.WaitForElement(By.LinkText("xxxxx"));
driver.FindElement(By.LinkText("xxxxx")).Click();

Answer 11

अजगर:

from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By

driver.find_element_by_id('someId').click()

WebDriverWait(driver, timeout).until(EC.presence_of_element_located((By.ID, 'someAnotherId'))

ईसी से आप अन्य स्थितियों को चुन सकते हैं और साथ ही यह कोशिश कर सकते हैं: http://selenium-python.readthedocs.org/api.html#module-selenium.webdriver.support. अप्रत्याशित_ conditions

Comments

इस प्रश्न को पाइथन नहीं, C # टैग किया गया है। यह उत्तर अप्रासंगिक है।

— उपयोगकर्ता

Answer 12

इस कोड को आज़माएं:

 New WebDriverWait(driver, TimeSpan.FromSeconds(10)).Until(Function(d) d.FindElement(By.Id("controlName")).Displayed)

Comments

आपको समझाना चाहिए कि आपने क्या किया है और यह समस्या क्यों हल करता है। और कृपया अपना कोड फॉर्मेट करें।

— Hering

Answer 13

स्पष्ट प्रतीक्षा करें

public static  WebDriverWait wait = new WebDriverWait(driver, 60);

उदाहरण:

wait.until(ExpectedConditions.visibilityOfElementLocated(UiprofileCre.UiaddChangeUserLink));

Answer 14

Rn222 और Aknuds1 का उपयोग एक ISearchContext का उपयोग करने के लिए करता है जो एक एकल तत्व, या एक सूची देता है। और तत्वों की एक न्यूनतम संख्या निर्दिष्ट की जा सकती है:

public static class SearchContextExtensions
{
    /// <summary>
    ///     Method that finds an element based on the search parameters within a specified timeout.
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeOutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <returns> The first element found that matches the condition specified</returns>
    public static IWebElement FindElement(this ISearchContext context, By by, uint timeOutInSeconds)
    {
        if (timeOutInSeconds > 0)
        {
            var wait = new DefaultWait<ISearchContext>(context);
            wait.Timeout = TimeSpan.FromSeconds(timeOutInSeconds);
            return wait.Until<IWebElement>(ctx => ctx.FindElement(by));
        }
        return context.FindElement(by);
    }
    /// <summary>
    ///     Method that finds a list of elements based on the search parameters within a specified timeout.
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <returns>A list of all the web elements that match the condition specified</returns>
    public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds)
    {

        if (timeoutInSeconds > 0)
        {
            var wait = new DefaultWait<ISearchContext>(context);
            wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
            return wait.Until<IReadOnlyCollection<IWebElement>>(ctx => ctx.FindElements(by));
        }
        return context.FindElements(by);
    }
    /// <summary>
    ///     Method that finds a list of elements with the minimum amount specified based on the search parameters within a specified timeout.<br/>
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <param name="minNumberOfElements">
    ///     The minimum number of elements that should meet the criteria before returning the list <para/>
    ///     If this number is not met, an exception will be thrown and no elements will be returned
    ///     even if some did meet the criteria
    /// </param>
    /// <returns>A list of all the web elements that match the condition specified</returns>
    public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds, int minNumberOfElements)
    {
        var wait = new DefaultWait<ISearchContext>(context);
        if (timeoutInSeconds > 0)
        {
            wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
        }

        // Wait until the current context found the minimum number of elements. If not found after timeout, an exception is thrown
        wait.Until<bool>(ctx => ctx.FindElements(by).Count >= minNumberOfElements);

        //If the elements were successfuly found, just return the list
        return context.FindElements(by);
    }

}

उदाहरण उपयोग:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost");
var main = driver.FindElement(By.Id("main"));
// It can be now used to wait when using elements to search
var btn = main.FindElement(By.Id("button"),10);
btn.Click();
//This will wait up to 10 seconds until a button is found
var button = driver.FindElement(By.TagName("button"),10)
//This will wait up to 10 seconds until a button is found, and return all the buttons found
var buttonList = driver.FindElements(By.TagName("button"),10)
//This will wait for 10 seconds until we find at least 5 buttons
var buttonsMin= driver.FindElements(By.TagName("button"), 10, 5);
driver.Close();

Answer 15

आप तत्व बदलने से पहले बहुत इंतजार नहीं करना चाहते हैं। इस कोड में वेबड्राइवर जारी होने से पहले 2 सेकंड तक प्रतीक्षा करता है।

WebDriverWait प्रतीक्षा = नया WebDriverWait (ड्राइवर, TimeSpan.FromMilliseconds (2000));
wait.Until (ExpectedConditions.VisibilityOfAllElementsLocatedBy (By.Name ( "html-नाम")));

Answer 16

चूँकि मैं पहले से ही मौजूद IWebElement का उपयोग करके पृष्ठ तत्वों की परिभाषा और पृष्ठ परीक्षण परिदृश्यों को अलग कर रहा हूँ, इस तरह किया जा सकता है:

public static void WaitForElementToBecomeVisibleWithinTimeout(IWebDriver driver, IWebElement element, int timeout)
{
    new WebDriverWait(driver, TimeSpan.FromSeconds(timeout)).Until(ElementIsVisible(element));
}

private static Func<IWebDriver, bool> ElementIsVisible(IWebElement element)
{
    return driver => {
        try
        {
            return element.Displayed;              
        }
        catch(Exception)
        {
            // If element is null, stale or if it cannot be located
            return false;
        }
    };
}

Answer 17

यह एक्सप्लोसिव वेट का उपयोग कर डोम में मौजूद किसी तत्व के लिए प्रतीक्षा करने के लिए पुन: प्रयोज्य कार्य है।

public void WaitForElement(IWebElement element, int timeout = 2)
{
    WebDriverWait wait = new WebDriverWait(webDriver, TimeSpan.FromMinutes(timeout));
    wait.IgnoreExceptionTypes(typeof(NoSuchElementException));
    wait.IgnoreExceptionTypes(typeof(StaleElementReferenceException));
    wait.Until<bool>(driver =>
    {
        try
        {
            return element.Displayed;
        }
        catch (Exception)
        {
            return false;
        }
    });
}

Comments

ढेर अतिप्रवाह में आपका स्वागत है, कृपया कोड-केवल उत्तर पोस्ट न करें।

— ट्रांसपेरेंसी के लिए जे जे और

Answer 18

हम इसे इस तरह हासिल कर सकते हैं:

public static IWebElement WaitForObject(IWebDriver DriverObj, By by, int TimeOut = 30)
{
    try
    {
        WebDriverWait Wait1 = new WebDriverWait(DriverObj, TimeSpan.FromSeconds(TimeOut));
        var WaitS = Wait1.Until(SeleniumExtras.WaitHelpers.ExpectedConditions.PresenceOfAllElementsLocatedBy(by));
        return WaitS[0];
    }
    catch (NoSuchElementException)
    {
        Reports.TestStep("Wait for Element(s) with xPath was failed in current context page.");
        throw;
    }
}

Answer 19

WebDriverWait प्रभावी नहीं होगा।

var driver = new FirefoxDriver(
    new FirefoxOptions().PageLoadStrategy = PageLoadStrategy.Eager
);
driver.Navigate().GoToUrl("xxx");
new WebDriverWait(driver, TimeSpan.FromSeconds(60))
    .Until(d => d.FindElement(By.Id("xxx"))); // a tag that close to the end

पेज "इंटरैक्टिव" होने के बाद यह तुरंत एक अपवाद फेंक देगा। मुझे पता नहीं क्यों लेकिन समय समाप्त होता है जैसे कि मौजूद नहीं है।

शायद SeleniumExtras.WaitHelpersकाम करता है, लेकिन मैंने कोशिश नहीं की। यह आधिकारिक है लेकिन दूसरे नगेट पैकेज में विभाजित किया गया था। आप C # सेलेनियम का उल्लेख कर सकते हैं 'ExpectedConditions अप्रचलित है' ।

मेरा उपयोग कर रहा है FindElementsऔर जाँच करें कि क्या Count == 0सच है, का उपयोग करें await Task.Delay। यह वास्तव में काफी कुशल नहीं है।

Answer 20

आप निम्नलिखित का उपयोग कर सकते हैं

WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0,0,5));
wait.Until(ExpectedConditions.ElementToBeClickable((By.Id("login")));

Answer 21

मुझे लगता है कि कई समाधान पहले से ही महान काम पोस्ट! हालाँकि, अगर किसी को किसी और चीज़ की ज़रूरत है, तो मैंने सोचा कि मैं दो समाधानों को पोस्ट करूँगा जो कि मैं व्यक्तिगत रूप से सेलेनियम C # में उपयोग करता हूँ ताकि यह पता चल सके कि कोई तत्व मौजूद है या नहीं! आशा है कि यह मदद करता है, चीयर्स!

public static class IsPresent
{
    public static bool isPresent(this IWebDriver driver, By bylocator)
    {

        bool variable = false;
        try
        {
            IWebElement element = driver.FindElement(bylocator);
            variable = element != null;
        }
       catch (NoSuchElementException){

       }
        return variable; 
    }

}

यहाँ दूसरा है

    public static class IsPresent2
{
    public static bool isPresent2(this IWebDriver driver, By bylocator)
    {
        bool variable = true; 
        try
        {
            IWebElement element = driver.FindElement(bylocator);

        }
        catch (NoSuchElementException)
        {
            variable = false; 
        }
        return variable; 
    }

}

Answer 22

 new WebDriverWait(driver, TimeSpan.FromSeconds(10)).
   Until(ExpectedConditions.PresenceOfAllElementsLocatedBy((By.Id("toast-container"))));

Comments

उम्मीद के

— मुताबिक

Answer 23

पहला जवाब अच्छा है, मेरी समस्या यह थी कि बिना किसी अपवाद के वेब ड्राइवर को ठीक से बंद नहीं किया था और यह वही पहला मूल्य रखता था जो मैंने इस्तेमाल किया था जो 1 सेकंड था।

अगर आपको भी यही समस्या है

restart you visual studioऔर यह सुनिश्चित करें कि all the exceptions are handledठीक से।

Comments

अब तक आपको पता होना चाहिए कि स्टैक ओवरफ्लो में जवाब देने का कोई आदेश नहीं है, इसलिए कोई "पहला जवाब" नहीं है

— एंटिटी हवाला

Answer 24

स्थिति के लिए सेलेनियम में प्रतीक्षा करने का तरीका खोज रहा था, इस धागे में उतरा और अब मैं इसका उपयोग करता हूं:

    WebDriverWait wait = new WebDriverWait(m_driver, TimeSpan.FromSeconds(10));
    wait.Until(d => ReadCell(row, col) != "");

ReadCell(row, col) != ""कोई भी हालत हो सकती है इस तरह से क्योंकि:

• यह मेरा है
• इनलाइनिंग की अनुमति देता है