zoukankan      html  css  js  c++  java
  • out

    https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out

    You can use the out contextual keyword in two contexts:

    out parameter modifier (C# Reference)

    https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-modifier

    When should I use out parameters?

    Out is good when you have a TryNNN function and it's clear that the out-parameter will always be set even if the function does not succeed.

    This allows you rely on the fact that the local variable you declare will be set rather than having to place checks later in your code against null.

    (A comment below indicates that the parameter could be set to null, so you may want to verify the documentation for the function you're calling to be sure if this is the case or not.)

    It makes the code a little clearer and easier to read.

    Another case is when you need to return some data and a status on the condition of the method like:

    public bool DoSomething(int arg1, out string result);

    In this case the return can indicate if the function succeeded and the result is stored in the out parameter.

    Admittedly, this example is contrived because you can design a way where the function simply returns a string, but you get the idea.

    A disadvantage is that you have to declare a local variable to use them:

    string result;
    if (DoSomething(5, out result))
        UpdateWithResult(result);

    Instead of:

    UpdateWithResult(DoSomething(5));

    However, that may not even be a disadvantage, it depends on the design you're going for.

    In the case of DateTime, both means (Parse and TryParse) are provided.

    http://www.yoda.arachsys.com/csharp/parameters.html

    Output parameters

    Like reference parameters, output parameters don't create a new storage location, but use the storage location of the variable specified on the invocation. Output parameters need the out modifier as part of both the declaration and the invocation - that means it's always clear when you're passing something as an output parameter.

    Output parameters are very similar to reference parameters. The only differences are:

    • The variable specified on the invocation doesn't need to have been assigned a value before it is passed to the function member. If the function member completes normally, the variable is considered to be assigned afterwards (so you can then "read" it).
    • The parameter is considered initially unassigned (in other words, you must assign it a value before you can "read" it in the function member).
    • The parameter must be assigned a value before the function member completes normally.

    Here is some example code showing this, with an int parameter (int is a value type, but if you understood reference parameters properly, you should be able to see what the behaviour for reference types is):

    void Foo (out int x)
    {
        // Can't read x here - it's considered unassigned
    
        // Assignment - this must happen before the method can complete normally
        x = 10;
    
        // The value of x can now be read:
        int a = x;
    }
    
    ...
    
    // Declare a variable but don't assign a value to it
    int y;
    
    // Pass it in as an output parameter, even though its value is unassigned
    Foo (out y);
    
    // It's now assigned a value, so we can write it out:
    Console.WriteLine (y);
    
  • 相关阅读:
    python中的operator.itemgetter函数
    win10下安装Cygwin配置gcc编译环境
    英文单词拼写纠错
    关于文本处理之结巴分词
    mysql 主从复制
    YII2.0 增删改查
    Linux screen命令简介
    Zookeeper简介与安装
    如何在Linux上安装Tomcat
    Java学习笔记之自定义异常
  • 原文地址:https://www.cnblogs.com/chucklu/p/7125355.html
Copyright © 2011-2022 走看看