LogExtentCollection Třída

Definice

Představuje kolekci LogExtent objektů přidružených k LogStore .Represents the collection of LogExtent objects associated with a LogStore.

public ref class LogExtentCollection sealed : System::Collections::Generic::IEnumerable<System::IO::Log::LogExtent ^>
public sealed class LogExtentCollection : System.Collections.Generic.IEnumerable<System.IO.Log.LogExtent>
type LogExtentCollection = class
    interface seq<LogExtent>
    interface IEnumerable
Public NotInheritable Class LogExtentCollection
Implements IEnumerable(Of LogExtent)
Dědičnost
LogExtentCollection
Implementuje

Příklady

Tento příklad ukazuje, jak použít LogExtent třídy a LogExtentCollection k přidání a emulaci rozsahů v protokolovém sekvenci.This example shows how to use the LogExtent and LogExtentCollection classes to add and emulate extents in a log sequence.

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.IO.Log;

namespace MyLogRecordSequence
{
    public class MyLog
    {
        string logName = "test.log";
        string logContainer = "MyExtent0";
        int containerSize = 32 * 1024;
        LogRecordSequence sequence = null;
        bool delete = true;

        // These are used in the TailPinned event handler.
        public static LogRecordSequence MySequence = null;
        public static bool AdvanceBase = true;

        public MyLog()
        {
            // Create a LogRecordSequence.
            sequence = new LogRecordSequence(this.logName,
                                              FileMode.CreateNew,
                                              FileAccess.ReadWrite,
                                              FileShare.None);

            // At least one container/extent must be added for Log Record Sequence.
            sequence.LogStore.Extents.Add(this.logContainer, this.containerSize);

            MySequence = sequence;
        }

        public void AddExtents()
        {
            // Add two additional extents. The extents are
            // of the same size as the first extent.
            sequence.LogStore.Extents.Add("MyExtent1");
            sequence.LogStore.Extents.Add("MyExtent2");
        }

        public void EnumerateExtents()
        {
            LogStore store = sequence.LogStore;

            Console.WriteLine("Enumerating Log Extents...");
            Console.WriteLine("    Extent Count: {0} extents", store.Extents.Count);
            Console.WriteLine("    Extents Are...");
            foreach (LogExtent extent in store.Extents)
            {
                Console.WriteLine("      {0} ({1}, {2})",
                                  Path.GetFileName(extent.Path),
                                  extent.Size,
                                  extent.State);
            }
            Console.WriteLine("    Free Extents: {0} Free", store.Extents.FreeCount);
        }

        public void SetLogPolicy()
        {
            Console.WriteLine();
            Console.WriteLine("Setting current log policy...");

            // SET LOG POLICY

            LogPolicy policy = sequence.LogStore.Policy;

            // Set AutoGrow policy. This enables the log to automatically grow
            // when the existing extents are full. New extents are added until
            // we reach the MaximumExtentCount extents.
            // AutoGrow policy is supported only in Windows Vista and not available in R2.

            //policy.AutoGrow = true;

            // Set the Growth Rate in terms of extents. This policy specifies
            // "how much" the log should grow.
            policy.GrowthRate = new PolicyUnit(2, PolicyUnitType.Extents);

            // Set the AutoShrink policy. This enables the log to automatically
            // shrink if the available free space exceeds the shrink percentage.
            // AutoGrow/shrink policy is supported only in Windows Vista and not available in R2.

            //policy.AutoShrinkPercentage = new PolicyUnit(30, PolicyUnitType.Percentage);

            // Set the PinnedTailThreshold policy.
            // A tail pinned event is triggered when there is no
            // log space available and log space may be freed by advancing the base.
            // The user must handle the tail pinned event by advancing the base of the log.
            // If the user is not able to move the base of the log, the user should report with exception in
            // the tail pinned handler.
            // PinnedTailThreashold policy dictates the amount of space that the TailPinned event requests
            // for advancing the base of the log. The amount of space can be in percentage or in terms of bytes
            // which is rounded off to the nearest containers in CLFS. The default is 35 percent.

            policy.PinnedTailThreshold = new PolicyUnit(10, PolicyUnitType.Percentage);

            // Set the maximum extents the log can have.
            policy.MaximumExtentCount = 6;

            // Set the minimum extents the log can have.
            policy.MinimumExtentCount = 2;

            // Set the prefix for new containers that are added.
            // when AutoGrow is enabled.
            //policy.NewExtentPrefix = "MyLogPrefix";

            // Set the suffix number for new containers that are added.
            // when AutoGrow is enabled.
            policy.NextExtentSuffix = 3;

            // Commit the log policy.
            policy.Commit();

            // Refresh updates the IO.Log policy properties with current log policy
            // set in the log.
            policy.Refresh();

            // LOG POLICY END
            //

            //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            // Setting up IO.Log provided capabilities...
            //

            // SET RETRY APPEND

            // IO.Log provides a mechanism similar to AutoGrow.
            // If the existing log is full and an append fails, setting RetryAppend
            // invokes the CLFS policy engine to add new extents and re-tries
            // record appends. If MaximumExtent count has been reached,
            // a SequenceFullException is thrown.
            //

            sequence.RetryAppend = true;

            // RETRY APPEND END

            // REGISTER FOR TAILPINNED EVENT NOTIFICATIONS

            // Register for TailPinned Event by passing in an event handler.
            // An event is raised when the log full condition is reached.
            // The user should either advance the base sequence number to the
            // nearest valid sequence number recommended in the tail pinned event or
            // report a failure that it is not able to advance the base sequence
            // number.
            //

            sequence.TailPinned += new EventHandler<TailPinnedEventArgs>(HandleTailPinned);

            Console.WriteLine("Done...");
        }

        public void ShowLogPolicy()
        {
            Console.WriteLine();
            Console.WriteLine("Showing current log policy...");

            LogPolicy policy = sequence.LogStore.Policy;

            Console.WriteLine("    Minimum extent count:  {0}", policy.MinimumExtentCount);
            Console.WriteLine("    Maximum extent count:  {0}", policy.MaximumExtentCount);
            Console.WriteLine("    Growth rate:           {0}", policy.GrowthRate);
            Console.WriteLine("    Pinned tail threshold: {0}", policy.PinnedTailThreshold);
            Console.WriteLine("    Auto shrink percent:   {0}", policy.AutoShrinkPercentage);
            Console.WriteLine("    Auto grow enabled:     {0}", policy.AutoGrow);
            Console.WriteLine("    New extent prefix:     {0}", policy.NewExtentPrefix);
            Console.WriteLine("    Next extent suffix:    {0}", policy.NextExtentSuffix);
    }

        // Append records. Appending three records.
        public void AppendRecords()
        {
            Console.WriteLine("Appending Log Records...");
            SequenceNumber previous = SequenceNumber.Invalid;

            previous = sequence.Append(CreateData("Hello World!"), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush);
            previous = sequence.Append(CreateData("This is my first Logging App"), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush);
            previous = sequence.Append(CreateData("Using LogRecordSequence..."), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush);
    
            Console.WriteLine("Done...");
        }

        // Read the records added to the log.
        public void ReadRecords()
        {
            Encoding enc = Encoding.Unicode;

            Console.WriteLine();

            Console.WriteLine("Reading Log Records...");
            try
            {
                foreach (LogRecord record in this.sequence.ReadLogRecords(this.sequence.BaseSequenceNumber, LogRecordEnumeratorType.Next))
                {
                    byte[] data = new byte[record.Data.Length];
                    record.Data.Read(data, 0, (int)record.Data.Length);
                    string mystr = enc.GetString(data);
                    Console.WriteLine("    {0}", mystr);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception {0} {1}", e.GetType(), e.Message);
            }

            Console.WriteLine();
        }

        public void FillLog()
        {
            bool append = true;

            while (append)
            {
                try
                {
                    sequence.Append(CreateData(16 * 1024), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush);
                }

                catch (SequenceFullException)
                {
                    Console.WriteLine("Log is Full...");
                    append = false;
                }
            }
        }

        // Dispose the record sequence and delete the log file.
        public void Cleanup()
        {
            // Dispose the sequence
            sequence.Dispose();

            // Delete the log file.
            if (delete)
            {
                try
                {
                    // This deletes the base log file and all the extents associated with the log.
                    LogStore.Delete(this.logName);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Exception {0} {1}", e.GetType(), e.Message);
                }
            }
        }

        // Converts the given data to an Array of ArraySegment<byte>
        public static IList<ArraySegment<byte>> CreateData(string str)
        {
            Encoding enc = Encoding.Unicode;

            byte[] array = enc.GetBytes(str);

            ArraySegment<byte>[] segments = new ArraySegment<byte>[1];
            segments[0] = new ArraySegment<byte>(array);

            return Array.AsReadOnly<ArraySegment<byte>>(segments);
        }

        public static IList<ArraySegment<byte>> CreateData(int size)
        {
            byte[] array = new byte[size];

            Random rnd = new Random();
            rnd.NextBytes(array);

            ArraySegment<byte>[] segments = new ArraySegment<byte>[1];
            segments[0] = new ArraySegment<byte>(array);

            return Array.AsReadOnly<ArraySegment<byte>>(segments);
        }

        public static SequenceNumber GetAdvanceBaseSeqNumber(SequenceNumber recTargetSeqNum)
        {
            SequenceNumber targetSequenceNumber = SequenceNumber.Invalid;

            Console.WriteLine("Getting actual target sequence number...");

            //
            // Implement the logic for returning a valid sequence number closer to
            // recommended target sequence number.
            //

            return targetSequenceNumber;
        }

        public static void HandleTailPinned(object arg, TailPinnedEventArgs tailPinnedEventArgs)
        {
            Console.WriteLine("TailPinned has fired");

            // Based on the implementation of a logging application, the log base can be moved
            // to free up more log space and if it is not possible to move the
            // base, the application should report by throwing an exception.

            if(MyLog.AdvanceBase)
            {
                try
                {
                    // TailPnnedEventArgs has the recommended sequence number and its generated
                    // based on PinnedTailThreshold policy.
                    // This does not map to an actual sequence number in the record sequence
                    // but an approximation and potentially frees up the threshold % log space
                    // when the log base is advanced to a valid sequence number closer to the
                    // recommended sequence number.
                    // The user should use this sequence number to locate a closest valid sequence
                    // number to advance the base of the log.

                    SequenceNumber recommendedTargetSeqNum = tailPinnedEventArgs.TargetSequenceNumber;

                    // Get the actual Target sequence number.
                    SequenceNumber actualTargetSeqNum = MyLog.GetAdvanceBaseSeqNumber(recommendedTargetSeqNum);

                    MySequence.AdvanceBaseSequenceNumber(actualTargetSeqNum);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Exception thrown {0} {1}", e.GetType(), e.Message);
                }
            }
            else
            {
                // Report back Error if under some conditions the log cannot
                // advance the base sequence number.

                Console.WriteLine("Reporting Error! Unable to move the base sequence number!");
                throw new IOException();
            }
        }
    }

    class LogSample
    {
        static void Main(string[] args)
        {
            // Create log record sequence.
            MyLog log = new MyLog();

            // Add additional extents.
            log.AddExtents();

            // Enumerate the current log extents.
            log.EnumerateExtents();

            // Set log policies and register for TailPinned event notifications.
            log.SetLogPolicy();

            log.ShowLogPolicy();

            // Append a few records and read the appended records.
            log.AppendRecords();
            log.ReadRecords();

            // Fill the Log to trigger log growth...and subsequent TailPinned notifications.
            log.FillLog();

            log.EnumerateExtents();

            log.Cleanup();
        }
    }
}


Imports System.IO
Imports System.Collections.Generic
Imports System.Text
Imports System.IO.Log

Namespace MyLogRecordSequence
    Public Class MyLog
        Private logName As String = "test.log"
        Private logContainer As String = "MyExtent0"
        Private containerSize As Integer = 32 * 1024
        Private sequence As LogRecordSequence = Nothing
        Private delete As Boolean = True

        ' These are used in the TailPinned event handler.
        Public Shared MySequence As LogRecordSequence = Nothing
        Public Shared AdvanceBase As Boolean = True

        Public Sub New()
            ' Create a LogRecordSequence.
            sequence = New LogRecordSequence(Me.logName, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)

            ' At least one container/extent must be added for Log Record Sequence.
            sequence.LogStore.Extents.Add(Me.logContainer, Me.containerSize)

            MySequence = sequence

        End Sub

        Public Sub AddExtents()
            ' Add two additional extents. The extents are 
            ' of the same size as the first extent.
            sequence.LogStore.Extents.Add("MyExtent1")
            sequence.LogStore.Extents.Add("MyExtent2")
        End Sub

        Public Sub EnumerateExtents()
            Dim store As LogStore = sequence.LogStore

            Console.WriteLine("Enumerating Log Extents...")
            Console.WriteLine("    Extent Count: {0} extents", store.Extents.Count)
            Console.WriteLine("    Extents Are...")
            For Each extent In store.Extents
                Console.WriteLine("      {0} ({1}, {2})", Path.GetFileName(extent.Path), extent.Size, extent.State)
            Next extent
            Console.WriteLine("    Free Extents: {0} Free", store.Extents.FreeCount)
        End Sub

        Public Sub SetLogPolicy()
            Console.WriteLine()
            Console.WriteLine("Setting current log policy...")

            ' SET LOG POLICY

            Dim policy As LogPolicy = sequence.LogStore.Policy

            ' Set AutoGrow policy. This enables the log to automatically grow
            ' when the existing extents are full. New extents are added until
            ' we reach the MaximumExtentCount extents.
            ' AutoGrow policy is supported only in Windows Vista and not available in R2.

            'policy.AutoGrow = true;

            ' Set the Growth Rate in terms of extents. This policy specifies
            ' "how much" the log should grow. 
            policy.GrowthRate = New PolicyUnit(2, PolicyUnitType.Extents)

            ' Set the AutoShrink policy. This enables the log to automatically
            ' shrink if the available free space exceeds the shrink percentage. 
            ' AutoGrow/shrink policy is supported only in Windows Vista and not available in R2.

            'policy.AutoShrinkPercentage = new PolicyUnit(30, PolicyUnitType.Percentage);

            ' Set the PinnedTailThreshold policy.
            ' A tail pinned event is triggered when there is no
            ' log space available and log space may be freed by advancing the base.
            ' The user must handle the tail pinned event by advancing the base of the log. 
            ' If the user is not able to move the base of the log, the user should report with exception in
            ' the tail pinned handler.
            ' PinnedTailThreashold policy dictates the amount of space that the TailPinned event requests 
            ' for advancing the base of the log. The amount of space can be in percentage or in terms of bytes 
            ' which is rounded off to the nearest containers in CLFS. The default is 35 percent.


            policy.PinnedTailThreshold = New PolicyUnit(10, PolicyUnitType.Percentage)

            ' Set the maximum extents the log can have.
            policy.MaximumExtentCount = 6

            ' Set the minimum extents the log can have.
            policy.MinimumExtentCount = 2

            ' Set the prefix for new containers that are added. 
            ' when AutoGrow is enabled.
            'policy.NewExtentPrefix = "MyLogPrefix";

            ' Set the suffix number for new containers that are added.
            ' when AutoGrow is enabled. 
            policy.NextExtentSuffix = 3

            ' Commit the log policy.
            policy.Commit()

            ' Refresh updates the IO.Log policy properties with current log policy 
            ' set in the log. 
            policy.Refresh()

            ' LOG POLICY END
            ' 

            '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            ' Setting up IO.Log provided capabilities...
            ' 

            ' SET RETRY APPEND

            ' IO.Log provides a mechanism similar to AutoGrow.
            ' If the existing log is full and an append fails, setting RetryAppend
            ' invokes the CLFS policy engine to add new extents and re-tries
            ' record appends. If MaximumExtent count has been reached, 
            ' a SequenceFullException is thrown. 
            ' 

            sequence.RetryAppend = True

            ' RETRY APPEND END

            ' REGISTER FOR TAILPINNED EVENT NOTIFICATIONS

            ' Register for TailPinned Event by passing in an event handler.
            ' An event is raised when the log full condition is reached.
            ' The user should either advance the base sequence number to the 
            ' nearest valid sequence number recommended in the tail pinned event or
            ' report a failure that it is not able to advance the base sequence 
            ' number. 
            '

            AddHandler sequence.TailPinned, AddressOf HandleTailPinned

            Console.WriteLine("Done...")
        End Sub

        Public Sub ShowLogPolicy()
            Console.WriteLine()
            Console.WriteLine("Showing current log policy...")

            Dim policy As LogPolicy = sequence.LogStore.Policy

            Console.WriteLine("    Minimum extent count:  {0}", policy.MinimumExtentCount)
            Console.WriteLine("    Maximum extent count:  {0}", policy.MaximumExtentCount)
            Console.WriteLine("    Growth rate:           {0}", policy.GrowthRate)
            Console.WriteLine("    Pinned tail threshold: {0}", policy.PinnedTailThreshold)
            Console.WriteLine("    Auto shrink percent:   {0}", policy.AutoShrinkPercentage)
            Console.WriteLine("    Auto grow enabled:     {0}", policy.AutoGrow)
            Console.WriteLine("    New extent prefix:     {0}", policy.NewExtentPrefix)
            Console.WriteLine("    Next extent suffix:    {0}", policy.NextExtentSuffix)

        End Sub

        ' Append records. Appending three records.  
        Public Sub AppendRecords()
            Console.WriteLine("Appending Log Records...")
            Dim previous As SequenceNumber = SequenceNumber.Invalid

            previous = sequence.Append(CreateData("Hello World!"), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush)
            previous = sequence.Append(CreateData("This is my first Logging App"), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush)
            previous = sequence.Append(CreateData("Using LogRecordSequence..."), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush)

            Console.WriteLine("Done...")
        End Sub


        ' Read the records added to the log. 
        Public Sub ReadRecords()
            Dim enc As Encoding = Encoding.Unicode

            Console.WriteLine()

            Console.WriteLine("Reading Log Records...")
            Try
                For Each record As LogRecord In Me.sequence.ReadLogRecords(Me.sequence.BaseSequenceNumber, LogRecordEnumeratorType.Next)
                    Dim data(record.Data.Length - 1) As Byte
                    record.Data.Read(data, 0, CInt(Fix(record.Data.Length)))
                    Dim mystr As String = enc.GetString(data)
                    Console.WriteLine("    {0}", mystr)
                Next record
            Catch e As Exception
                Console.WriteLine("Exception {0} {1}", e.GetType(), e.Message)
            End Try

            Console.WriteLine()
        End Sub

        Public Sub FillLog()
            Dim append As Boolean = True

            Do While append
                Try
                    sequence.Append(CreateData(16 * 1024), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush)

                Catch e1 As SequenceFullException
                    Console.WriteLine("Log is Full...")
                    append = False
                End Try
            Loop
        End Sub

        ' Dispose the record sequence and delete the log file. 
        Public Sub Cleanup()
            ' Dispose the sequence
            sequence.Dispose()

            ' Delete the log file.
            If delete Then
                Try
                    ' This deletes the base log file and all the extents associated with the log.
                    LogStore.Delete(Me.logName)
                Catch e As Exception
                    Console.WriteLine("Exception {0} {1}", e.GetType(), e.Message)
                End Try
            End If
        End Sub

        ' Converts the given data to an Array of ArraySegment<byte> 
        Public Shared Function CreateData(ByVal str As String) As IList(Of ArraySegment(Of Byte))
            Dim enc As Encoding = Encoding.Unicode

            Dim array() As Byte = enc.GetBytes(str)

            Dim segments(0) As ArraySegment(Of Byte)
            segments(0) = New ArraySegment(Of Byte)(array)

            Return System.Array.AsReadOnly(Of ArraySegment(Of Byte))(segments)
        End Function

        Public Shared Function CreateData(ByVal size As Integer) As IList(Of ArraySegment(Of Byte))
            Dim array(size - 1) As Byte

            Dim rand As New Random()
            rand.NextBytes(array)

            Dim segments(0) As ArraySegment(Of Byte)
            segments(0) = New ArraySegment(Of Byte)(array)

            Return System.Array.AsReadOnly(Of ArraySegment(Of Byte))(segments)
        End Function

        Public Shared Function GetAdvanceBaseSeqNumber(ByVal recTargetSeqNum As SequenceNumber) As SequenceNumber
            Dim targetSequenceNumber As SequenceNumber = SequenceNumber.Invalid

            Console.WriteLine("Getting actual target sequence number...")

            ' 
            ' Implement the logic for returning a valid sequence number closer to
            ' recommended target sequence number. 
            '

            Return targetSequenceNumber
        End Function

        Public Shared Sub HandleTailPinned(ByVal arg As Object, ByVal tailPinnedEventArgs As TailPinnedEventArgs)
            Console.WriteLine("TailPinned has fired")

            ' Based on the implementation of a logging application, the log base can be moved
            ' to free up more log space and if it is not possible to move the 
            ' base, the application should report by throwing an exception.

            If MyLog.AdvanceBase Then
                Try
                    ' TailPnnedEventArgs has the recommended sequence number and its generated 
                    ' based on PinnedTailThreshold policy. 
                    ' This does not map to an actual sequence number in the record sequence
                    ' but an approximation and potentially frees up the threshold % log space
                    ' when the log base is advanced to a valid sequence number closer to the 
                    ' recommended sequence number. 
                    ' The user should use this sequence number to locate a closest valid sequence
                    ' number to advance the base of the log.

                    Dim recommendedTargetSeqNum As SequenceNumber = tailPinnedEventArgs.TargetSequenceNumber

                    ' Get the actual Target sequence number.
                    Dim actualTargetSeqNum As SequenceNumber = MyLog.GetAdvanceBaseSeqNumber(recommendedTargetSeqNum)

                    MySequence.AdvanceBaseSequenceNumber(actualTargetSeqNum)
                Catch e As Exception
                    Console.WriteLine("Exception thrown {0} {1}", e.GetType(), e.Message)
                End Try
            Else
                ' Report back Error if under some conditions the log cannot
                ' advance the base sequence number.

                Console.WriteLine("Reporting Error! Unable to move the base sequence number!")
                Throw New IOException()
            End If
        End Sub
    End Class

    Friend Class LogSample
        Shared Sub Main(ByVal args() As String)
            ' Create log record sequence.
            Dim log As New MyLog()

            ' Add additional extents.
            log.AddExtents()

            ' Enumerate the current log extents.
            log.EnumerateExtents()

            ' Set log policies and register for TailPinned event notifications. 
            log.SetLogPolicy()

            log.ShowLogPolicy()

            ' Append a few records and read the appended records. 
            log.AppendRecords()
            log.ReadRecords()

            ' Fill the Log to trigger log growth...and subsequent TailPinned notifications.
            log.FillLog()

            log.EnumerateExtents()

            log.Cleanup()
        End Sub
    End Class
End Namespace

Poznámky

Tato třída obsahuje kolekci LogExtent objektů přidružených k LogStore .This class contains a collection of LogExtent objects associated with a LogStore. LogStoreInstance ukládá svá data do kolekce rozsahů disků reprezentovaných LogExtent instancemi.A LogStore instance stores its data in a collection of disk extents, represented by LogExtent instances. Konkrétní LogExtent hodnota je spojená s jedním LogStore LogExtent objektem a objekty ve stejné LogStore velikosti mají stejnou velikost.A particular LogExtent is associated with one LogStore, and LogExtent objects in the same LogStore are of identical size. Přidání prostoru do a z LogStore instance v případě přírůstku rozsahu se přidá a odebere.Space is added to and removed from a LogStore instance in extent increments.

I když LogExtent jsou objekty na disku reprezentovány jako soubory, neměly by být přesunuty ani odstraněny jako běžné soubory.Although LogExtent objects are represented on disk as files, they should not be moved or deleted as normal files. Místo toho byste měli použít metody poskytované touto třídou pro přidávání a odstraňování LogExtent instancí přímo.Rather, you should use the methods provided by this class for adding and deleting LogExtent instances directly. Rozsahy jsou obvykle odebrány, pokud již neobsahují žádná aktivní data.Extents are usually removed when they no longer contain any active data. Nicméně pokud force je parametr v Remove metodě true , je vyvolána výjimka, pokud je nelze okamžitě odebrat.However, if the force parameter in the Remove method is true, an exception is thrown if they cannot be removed immediately.

Poslední rozsah nemůžete odebrat v LogExtentCollection , což znamená, že Count po přidání rozsahu nemůže být vlastnost nula.You cannot remove the last extent in the LogExtentCollection, which means that the Count property cannot be zero after an extent is added.

Vlastnosti

Count

Získá počet rozsahů protokolů v kolekci.Gets the number of log extents in the collection.

FreeCount

Získá počet volných LogExtent instancí v kolekci, tj LogExtent . počet instancí, které neobsahují žádná data.Gets the number of free LogExtent instances in the collection, that is, the number of LogExtent instances that do not contain any data.

Metody

Add(String)

Přidá LogExtent instanci do kolekce.Adds a LogExtent instance to the collection.

Add(String, Int64)

Vytvoří novou LogExtent se zadanou velikostí a přidá ji do kolekce.Creates a new LogExtent with the specified size and adds it to the collection.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetEnumerator()

Získá enumerátor pro LogExtent instance v této kolekci.Gets an enumerator for the LogExtent instances in this collection. Tuto metodu nelze zdědit.This method cannot be inherited.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
Remove(LogExtent, Boolean)

Odebere zadanou LogExtent instanci z kolekce.Removes the specified LogExtent instance from the collection.

Remove(String, Boolean)

Odebere LogExtent instanci se zadanou cestou z kolekce.Removes the LogExtent instance with the specified path from the collection.

ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

IEnumerable.GetEnumerator()

Získá enumerátor pro LogExtent instance v této kolekci.Gets an enumerator for the LogExtent instances in this collection. Tuto metodu nelze zdědit.This method cannot be inherited.

Metody rozšíření

CopyToDataTable<T>(IEnumerable<T>)

Vrátí DataTable , který obsahuje kopie DataRow objektů, a to tak, že předané vstupní IEnumerable<T> objekt, kde je obecný parametr T DataRow .Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru.The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru a zadaná funkce slouží k výběru hodnoty výsledku.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda všechny prvky sekvence splní podmínku.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje nějaké prvky.Determines whether a sequence contains any elements.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda kterýkoli prvek sekvence splňuje podmínku.Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IEnumerable<TSource>, TSource)

Připojí hodnotu na konec sekvence.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup zadaný jako IEnumerable<T> .Returns the input typed as IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá průměr sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá průměr sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá průměr sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá průměr sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá průměr sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Zřetězí dvě sekvence.Concatenates two sequences.

Contains<TSource>(IEnumerable<TSource>, TSource)

Určuje, zda sekvence obsahuje zadaný element pomocí výchozí porovnávače rovnosti.Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Určuje, zda sekvence obsahuje zadaný element pomocí zadaného prvku IEqualityComparer<T> .Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Vrátí počet prvků v sekvenci.Returns the number of elements in a sequence.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci vyhovuje podmínce.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Vrátí prvky zadané sekvence nebo zadanou hodnotu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Vrátí odlišné prvky z sekvence pomocí výchozí porovnávací metody pro porovnání hodnot.Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vrátí odlišné prvky z sekvence pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v sekvenci.Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří množinový rozdíl dvou sekvencí pomocí výchozí porovnávací metody pro porovnání hodnot.Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří množinový rozdíl dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence.Returns the first element of a sequence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek v sekvenci, která splňuje zadanou podmínku.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče.Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a porovná klíče s použitím zadané porovnávací metody.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a projekty prvků pro každou skupinu pomocí zadané funkce.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Seskupí prvky pořadí podle funkce selektoru klíče.Groups the elements of a sequence according to a key selector function. Klíče jsou porovnány pomocí porovnávacího prvku a jednotlivé prvky skupiny jsou probíhají pomocí zadané funkce.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Klíče jsou porovnány pomocí zadané porovnávací metody.The keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Prvky každé skupiny jsou probíhají pomocí zadané funkce.The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Hodnoty klíčů jsou porovnány pomocí zadané porovnávací metody a prvky každé skupiny jsou probíhají pomocí zadané funkce.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

Koreluje prvky dvou sekvencí na základě rovnosti klíčů a skupin výsledků.Correlates the elements of two sequences based on equality of keys and groups the results. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupí výsledky.Correlates the elements of two sequences based on key equality and groups the results. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří průniky sady dvou sekvencí pomocí výchozí porovnávače rovnosti pro porovnání hodnot.Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří průnik dvou sekvencí sady pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Koreluje prvky dvou sekvencí založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence.Returns the last element of a sequence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, který splňuje zadanou podmínku.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the last element of a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>)

Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci.Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí hodnotu Int64 reprezentující, kolik prvků v sekvenci splní podmínku.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.Returns the maximum value in a generic sequence.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Single value.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí maximální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.Returns the minimum value in a generic sequence.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Single value.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí minimální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence ve vzestupném pořadí podle klíče.Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence ve vzestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence v sestupném pořadí podle klíče.Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence v sestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Přidá hodnotu na začátek sekvence.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Obrátí pořadí prvků v sekvenci.Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Projektuje každý prvek sekvence do nového formuláře.Projects each element of a sequence into a new form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Projektuje každý prvek sekvence do nového formuláře zahrnutím indexu elementu.Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Projekty jednotlivé prvky sekvence do IEnumerable<T> a sloučí výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projekty jsou jednotlivé prvky sekvence IEnumerable<T> a jsou shrnuty ve výsledných sekvencích do jedné sekvence.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. Index každého zdrojového elementu se používá v projektované podobě daného prvku.The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. Index jednotlivých zdrojových elementů se používá v mezilehlém projektovém formuláři tohoto prvku.The index of each source element is used in the intermediate projected form of that element.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Určuje, zda jsou dvě sekvence stejné, porovnáním prvků s použitím výchozí porovnávače rovnosti pro svůj typ.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Určuje, zda se dvě sekvence rovnají porovnáním jejich prvků pomocí zadaného parametru IEqualityComparer<T> .Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence nebo výchozí hodnotu, pokud je sekvence prázdná. Tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, nebo výchozí hodnotu, pokud žádný takový prvek neexistuje. Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínky.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IEnumerable<TSource>, Int32)

Obchází zadaný počet prvků v sekvenci a vrátí zbývající prvky.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou vyčíslitelné kolekci, která obsahuje prvky z source s posledními count prvky zdrojové kolekce vynechány.Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá součet sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá součet sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá součet sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá součet sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá součet sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Take<TSource>(IEnumerable<TSource>, Int32)

Vrátí zadaný počet souvislých prvků od začátku sekvence.Returns a specified number of contiguous elements from the start of a sequence.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou vyčíslitelné kolekci, která obsahuje poslední count prvky z source .Returns a new enumerable collection that contains the last count elements from source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z IEnumerable<T> .Creates an array from a IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří Dictionary<TKey,TValue> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to specified key selector and element selector functions.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče, porovnávání a funkci selektor elementu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function, a comparer, and an element selector function.

ToHashSet<TSource>(IEnumerable<TSource>)

Vytvoří HashSet<T> z IEnumerable<T> .Creates a HashSet<T> from an IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří HashSet<T> z s IEnumerable<T> pomocí comparer k porovnání klíčů.Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Vytvoří List<T> z IEnumerable<T> .Creates a List<T> from an IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to specified key selector and element selector functions.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče, porovnávací funkce a funkci selektor elementu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function, a comparer and an element selector function.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří sjednocení dvou sekvencí pomocí výchozí porovnávače rovnosti.Produces the set union of two sequences by using the default equality comparer.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří sjednocení ze dvou sekvencí pomocí zadaného typu IEqualityComparer<T> .Produces the set union of two sequences by using a specified IEqualityComparer<T>.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate. Index každého elementu se používá v Logic funkce predikátu.Each element's index is used in the logic of the predicate function.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Vytvoří sekvenci řazených kolekcí členů s prvky ze dvou zadaných sekvencí.Produces a sequence of tuples with elements from the two specified sequences.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Použije zadanou funkci na odpovídající prvky dvou sekvencí a vytvoří tak sekvenci výsledků.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable .Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Převede obecný IEnumerable<T> na obecný IQueryable<T> .Converts a generic IEnumerable<T> to a generic IQueryable<T>.

Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Vrátí filtrovanou kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci.Returns a filtered collection of the child elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.Removes every node in the source collection from its parent node.

Platí pro

Viz také