YöntemlerMethods

Yöntem, bir türle ilişkili bir işlevdir.A method is a function that is associated with a type. Nesne yönelimli programlamada, nesnelerin ve türlerin işlevselliğini ve davranışını ortaya çıkarmak ve uygulamak için yöntemler kullanılır.In object-oriented programming, methods are used to expose and implement the functionality and behavior of objects and types.

SözdizimiSyntax

// Instance method definition.
[ attributes ]
member [inline] self-identifier.method-name parameter-list [ : return-type ] =
    method-body

// Static method definition.
[ attributes ]
static member [inline] method-name parameter-list [ : return-type ] =
    method-body

// Abstract method declaration or virtual dispatch slot.
[ attributes ]
abstract member method-name : type-signature

// Virtual method declaration and default implementation.
[ attributes ]
abstract member method-name : type-signature
[ attributes ]
default self-identifier.method-name parameter-list [ : return-type ] =
    method-body

// Override of inherited virtual method.
[ attributes ]
override self-identifier.method-name parameter-list [ : return-type ] =
    method-body

// Optional and DefaultParameterValue attributes on input parameters
[ attributes ]
[ modifier ] member [inline] self-identifier.method-name ([<Optional; DefaultParameterValue( default-value )>] input) [ : return-type ]

AçıklamalarRemarks

Önceki sözdiziminde, yöntem bildirimlerinin ve tanımlarının çeşitli biçimlerini görebilirsiniz.In the previous syntax, you can see the various forms of method declarations and definitions. Uzun yöntem gövdelerinde, bir satır sonu eşit işareti (=) izler ve tüm yöntem gövdesi girintilir.In longer method bodies, a line break follows the equal sign (=), and the whole method body is indented.

Öznitelikler herhangi bir yöntem bildirimine uygulanabilir.Attributes can be applied to any method declaration. Yöntem tanımı için sözdiziminden önce gelir ler ve genellikle ayrı bir satırda listelenirler.They precede the syntax for a method definition and are usually listed on a separate line. Daha fazla bilgi için Özniteliklerebakın.For more information, see Attributes.

Yöntemler işaretlenebilir. inlineMethods can be marked inline. Hakkında bilgi inlineiçin Bkz. Satır İçi Fonksiyonlar.For information about inline, see Inline Functions.

Satır içi olmayan yöntemler, tür içinde özyinelemeli olarak kullanılabilir; anahtar kelimeyi rec açıkça kullanmaya gerek yoktur.Non-inline methods can be used recursively within the type; there is no need to explicitly use the rec keyword.

Örnek YöntemleriInstance Methods

Örnek yöntemleri member anahtar kelime ve kendi kendini tanımlayıcıile bildirilir, ardından bir dönem (.) ve yöntem adı ve parametreleri.Instance methods are declared with the member keyword and a self-identifier, followed by a period (.) and the method name and parameters. Bağlamalar için let olduğu gibi, parametre listesi bir desen olabilir.As is the case for let bindings, the parameter-list can be a pattern. Genellikle, yöntem parametrelerini parantez içinde bir tuple formuna alarsınız, bu da yöntemlerdiğer .NET Framework dillerinde oluşturulduklarında F#'da nasıl görünür?Typically, you enclose method parameters in parentheses in a tuple form, which is the way methods appear in F# when they are created in other .NET Framework languages. Ancak, körili form (boşluklara göre ayrılmış parametreler) de yaygındır ve diğer desenler de desteklenir.However, the curried form (parameters separated by spaces) is also common, and other patterns are supported also.

Aşağıdaki örnek, soyut olmayan bir örnek yönteminin tanımını ve kullanımını göstermektedir.The following example illustrates the definition and use of a non-abstract instance method.

type SomeType(factor0: int) =
   let factor = factor0
   member this.SomeMethod(a, b, c) =
      (a + b + c) * factor

   member this.SomeOtherMethod(a, b, c) =
      this.SomeMethod(a, b, c) * factor

Örnek yöntemleri içinde, let bağlamaları kullanılarak tanımlanan alanlara erişmek için öz tanımlayıcıyı kullanmayın.Within instance methods, do not use the self identifier to access fields defined by using let bindings. Diğer üyelere ve özelliklere erişirken kendi kendini tanımlayıcıyı kullanın.Use the self identifier when accessing other members and properties.

Statik YöntemlerStatic Methods

Anahtar kelime, static bir yöntemin bir örnek olmadan çağrılabileceğini ve bir nesne örneğiyle ilişkilendirilmediğini belirtmek için kullanılır.The keyword static is used to specify that a method can be called without an instance and is not associated with an object instance. Aksi takdirde, yöntemler örnek yöntemleridir.Otherwise, methods are instance methods.

Sonraki bölümde ki let örnekte, anahtar kelimeyle bildirilen alanlar, member anahtar kelimeyle bildirilen özellik static üyeleri ve anahtar kelimeyle birlikte bildirilen statik bir yöntem gösterilmektedir.The example in the next section shows fields declared with the let keyword, property members declared with the member keyword, and a static method declared with the static keyword.

Aşağıdaki örnekte statik yöntemlerin tanımı ve kullanımı gösterilmektedir.The following example illustrates the definition and use of static methods. Bu yöntem tanımlarının önceki SomeType bölümde sınıfta olduğunu varsayalım.Assume that these method definitions are in the SomeType class in the previous section.

static member SomeStaticMethod(a, b, c) =
   (a + b + c)

static member SomeOtherStaticMethod(a, b, c) =
   SomeType.SomeStaticMethod(a, b, c) * 100

Soyut ve Sanal YöntemlerAbstract and Virtual Methods

Anahtar kelime, abstract bir yöntemin sanal bir gönderme yuvasına sahip olduğunu ve sınıfta bir tanımı nın olmayabilir olduğunu belirtir.The keyword abstract indicates that a method has a virtual dispatch slot and might not have a definition in the class. Sanal gönderme yuvası, nesne yönelimli bir türde sanal işlev çağrılarını aramak için çalışma zamanında kullanılan dahili olarak korunan işlevler tablosundaki bir giriştir.A virtual dispatch slot is an entry in an internally maintained table of functions that is used at run time to look up virtual function calls in an object-oriented type. Sanal gönderme mekanizması, nesne yönelimli programlamanın önemli bir özelliği olan çok biçimliliğiuygulayan mekanizmadır.The virtual dispatch mechanism is the mechanism that implements polymorphism, an important feature of object-oriented programming. Tanımı olmayan en az bir soyut metod olan bir sınıf soyut bir sınıftır, bu da o sınıftan hiçbir örnek oluşturulamayacağı anlamına gelir.A class that has at least one abstract method without a definition is an abstract class, which means that no instances can be created of that class. Soyut sınıflar hakkında daha fazla bilgi için bkz.For more information about abstract classes, see Abstract Classes.

Soyut yöntem bildirimleri bir yöntem gövdesi içermez.Abstract method declarations do not include a method body. Bunun yerine, yöntemin adı bir iki nokta üst üste (:) ve yöntem için bir tür imza.Instead, the name of the method is followed by a colon (:) and a type signature for the method. Bir yöntemin tür imzası, parametre adları dışında, Görsel Stüdyo Kodu Düzenleyicisi'ndeki bir yöntem adı üzerinde fare işaretçisini duraklattığınızda IntelliSense tarafından gösterilenle aynıdır.The type signature of a method is the same as that shown by IntelliSense when you pause the mouse pointer over a method name in the Visual Studio Code Editor, except without parameter names. Tür imzaları da etkileşimli çalışırken, tercüman, fsi.exe tarafından görüntülenir.Type signatures are also displayed by the interpreter, fsi.exe, when you are working interactively. Bir yöntemin tür imzası, parametrelerin türlerinin listelenmesiyle oluşur ve ardından dönüş türü, uygun ayırıcı sembollerle oluşturulur.The type signature of a method is formed by listing out the types of the parameters, followed by the return type, with appropriate separator symbols. Curried parametreleri -> ile ayrılır ve tuple parametreleri ile *ayrılır .Curried parameters are separated by -> and tuple parameters are separated by *. İade değeri her zaman bir -> sembol le bağımsız değişkenlerden ayrılır.The return value is always separated from the arguments by a -> symbol. Parantez, işlev türünün bir parametre olması gibi karmaşık parametreleri gruplandırmak veya bir tuple'ın iki parametre yerine tek bir parametre olarak ne zaman ele alındığını belirtmek için kullanılabilir.Parentheses can be used to group complex parameters, such as when a function type is a parameter, or to indicate when a tuple is treated as a single parameter rather than as two parameters.

Ayrıca, bu konuda sözdizimi bloğunda gösterildiği gibi, default tanımı sınıfa ekleyerek ve anahtar sözcüğü kullanarak soyut yöntemler varsayılan tanımlar da verebilirsiniz.You can also give abstract methods default definitions by adding the definition to the class and using the default keyword, as shown in the syntax block in this topic. Aynı sınıfta tanımı olan soyut bir yöntem, diğer .NET Framework dillerinde sanal yönteme eşdeğerdir.An abstract method that has a definition in the same class is equivalent to a virtual method in other .NET Framework languages. Bir tanım var olsun abstract veya olmasın, anahtar kelime sınıf için sanal işlev tablosunda yeni bir gönderme yuvası oluşturur.Whether or not a definition exists, the abstract keyword creates a new dispatch slot in the virtual function table for the class.

Bir taban sınıfın soyut yöntemlerini uygulayıp uygulamadığına bakılmaksızın, türemiş sınıflar soyut yöntemlerin uygulamalarını sağlayabilir.Regardless of whether a base class implements its abstract methods, derived classes can provide implementations of abstract methods. Türemiş bir sınıfta soyut bir yöntem uygulamak için, türemiş sınıfta, anahtar override sözcüğü kullanmak dışında aynı ada ve imzaya sahip bir yöntem tanımlayın default ve yöntem gövdesini sağlayın.To implement an abstract method in a derived class, define a method that has the same name and signature in the derived class, except use the override or default keyword, and provide the method body. Anahtar override kelimeler default ve tam olarak aynı şey anlamına gelir.The keywords override and default mean exactly the same thing. Yeni override yöntem taban sınıf uygulamasını geçersiz kılıyorsa kullanın; özgün default özet bildirimle aynı sınıfta bir uygulama oluşturduğunuzda kullanın.Use override if the new method overrides a base class implementation; use default when you create an implementation in the same class as the original abstract declaration. Taban sınıfta abstract soyut olarak bildirilen yöntemi uygulayan yöntemde anahtar sözcüğü kullanmayın.Do not use the abstract keyword on the method that implements the method that was declared abstract in the base class.

Aşağıdaki örnekte, bir Rotate .NET Framework sanal yöntemieşdeğeri olan varsayılan bir uygulama olan soyut bir yöntem gösterilmiştir.The following example illustrates an abstract method Rotate that has a default implementation, the equivalent of a .NET Framework virtual method.

type Ellipse(a0 : float, b0 : float, theta0 : float) =
    let mutable axis1 = a0
    let mutable axis2 = b0
    let mutable rotAngle = theta0
    abstract member Rotate: float -> unit
    default this.Rotate(delta : float) = rotAngle <- rotAngle + delta

Aşağıdaki örnekte, taban sınıf yöntemini geçersiz kılan türetilmiş bir sınıf gösterilmiştir.The following example illustrates a derived class that overrides a base class method. Bu durumda, geçersiz kılma, yöntemin hiçbir şey yapamaması için davranışı değiştirir.In this case, the override changes the behavior so that the method does nothing.

type Circle(radius : float) =
    inherit Ellipse(radius, radius, 0.0)
     // Circles are invariant to rotation, so do nothing.
    override this.Rotate(_) = ()

Aşırı Yüklenmiş YöntemlerOverloaded Methods

Aşırı yüklenen yöntemler, belirli bir türde aynı adlara sahip ancak farklı bağımsız değişkenleri olan yöntemlerdir.Overloaded methods are methods that have identical names in a given type but that have different arguments. F#'da, genellikle aşırı yüklü yöntemler yerine isteğe bağlı bağımsız değişkenler kullanılır.In F#, optional arguments are usually used instead of overloaded methods. Ancak, aşırı yüklenen yöntemler, bağımsız değişkenler tuple şeklinde değil, curried şeklinde olması koşuluyla, dilde izin verilir.However, overloaded methods are permitted in the language, provided that the arguments are in tuple form, not curried form.

İsteğe Bağlı Bağımsız DeğişkenlerOptional Arguments

F# 4.1 ile başlayarak, yöntemlerde varsayılan parametre değerine sahip isteğe bağlı bağımsız değişkenler de olabilir.Starting with F# 4.1, you can also have optional arguments with a default parameter value in methods. Bu, C# kodu ile birlikte çalışma işlemini kolaylaştırmak içindir.This is to help facilitate interoperation with C# code. Aşağıdaki örnek sözdizimini gösterir:The following example demonstrates the syntax:

// A class with a method M, which takes in an optional integer argument.
type C() =
    _.M([<Optional; DefaultParameterValue(12)>] i) = i + 1

Için DefaultParameterValue geçirilen değerin giriş türüyle eşleşmesi gerektiğini unutmayın.Note that the value passed in for DefaultParameterValue must match the input type. Yukarıdaki örnekte, bir int.In the above sample, it is an int. Tamsayı olmayan bir değeri derleme DefaultParameterValue hatasına neden olur.Attempting to pass a non-integer value into DefaultParameterValue would result in a compile error.

Örnek: Özellikler ve YöntemlerExample: Properties and Methods

Aşağıdaki örnek, alanlar, özel işlevler, özellikler ve statik bir yöntem örnekleri içeren bir tür içerir.The following example contains a type that has examples of fields, private functions, properties, and a static method.

type RectangleXY(x1 : float, y1: float, x2: float, y2: float) =
    // Field definitions.
    let height = y2 - y1
    let width = x2 - x1
    let area = height * width
    // Private functions.
    static let maxFloat (x: float) (y: float) =
      if x >= y then x else y
    static let minFloat (x: float) (y: float) =
      if x <= y then x else y
    // Properties.
    // Here, "this" is used as the self identifier,
    // but it can be any identifier.
    member this.X1 = x1
    member this.Y1 = y1
    member this.X2 = x2
    member this.Y2 = y2
    // A static method.
    static member intersection(rect1 : RectangleXY, rect2 : RectangleXY) =
       let x1 = maxFloat rect1.X1 rect2.X1
       let y1 = maxFloat rect1.Y1 rect2.Y1
       let x2 = minFloat rect1.X2 rect2.X2
       let y2 = minFloat rect1.Y2 rect2.Y2
       let result : RectangleXY option =
         if ( x2 > x1 && y2 > y1) then
           Some (RectangleXY(x1, y1, x2, y2))
         else
           None
       result

// Test code.
let testIntersection =
    let r1 = RectangleXY(10.0, 10.0, 20.0, 20.0)
    let r2 = RectangleXY(15.0, 15.0, 25.0, 25.0)
    let r3 : RectangleXY option = RectangleXY.intersection(r1, r2)
    match r3 with
    | Some(r3) -> printfn "Intersection rectangle: %f %f %f %f" r3.X1 r3.Y1 r3.X2 r3.Y2
    | None -> printfn "No intersection found."

testIntersection

Ayrıca bkz.See also